blob: 56be318198971f40ea9a57703530260ad51e4067 [file] [log] [blame]
Brett Russ20f733e2005-09-01 18:26:17 -04001/*
2 * sata_mv.c - Marvell SATA support
3 *
Mark Lord40f21b12009-03-10 18:51:04 -04004 * Copyright 2008-2009: Marvell Corporation, all rights reserved.
Jeff Garzik8b260242005-11-12 12:32:50 -05005 * Copyright 2005: EMC Corporation, all rights reserved.
Jeff Garzike2b1be52005-11-18 14:04:23 -05006 * Copyright 2005 Red Hat, Inc. All rights reserved.
Brett Russ20f733e2005-09-01 18:26:17 -04007 *
Mark Lord40f21b12009-03-10 18:51:04 -04008 * Originally written by Brett Russ.
9 * Extensive overhaul and enhancement by Mark Lord <mlord@pobox.com>.
10 *
Brett Russ20f733e2005-09-01 18:26:17 -040011 * Please ALWAYS copy linux-ide@vger.kernel.org on emails.
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; version 2 of the License.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 */
27
Jeff Garzik4a05e202007-05-24 23:40:15 -040028/*
Mark Lord85afb932008-04-19 14:54:41 -040029 * sata_mv TODO list:
30 *
Mark Lord85afb932008-04-19 14:54:41 -040031 * --> Develop a low-power-consumption strategy, and implement it.
32 *
Mark Lord2b748a02009-03-10 22:01:17 -040033 * --> Add sysfs attributes for per-chip / per-HC IRQ coalescing thresholds.
Mark Lord85afb932008-04-19 14:54:41 -040034 *
35 * --> [Experiment, Marvell value added] Is it possible to use target
36 * mode to cross-connect two Linux boxes with Marvell cards? If so,
37 * creating LibATA target mode support would be very interesting.
38 *
39 * Target mode, for those without docs, is the ability to directly
40 * connect two SATA ports.
41 */
Jeff Garzik4a05e202007-05-24 23:40:15 -040042
Mark Lord65ad7fef2009-04-06 15:24:14 -040043/*
44 * 80x1-B2 errata PCI#11:
45 *
46 * Users of the 6041/6081 Rev.B2 chips (current is C0)
47 * should be careful to insert those cards only onto PCI-X bus #0,
48 * and only in device slots 0..7, not higher. The chips may not
49 * work correctly otherwise (note: this is a pretty rare condition).
50 */
51
Brett Russ20f733e2005-09-01 18:26:17 -040052#include <linux/kernel.h>
53#include <linux/module.h>
54#include <linux/pci.h>
55#include <linux/init.h>
56#include <linux/blkdev.h>
57#include <linux/delay.h>
58#include <linux/interrupt.h>
Andrew Morton8d8b6002008-02-04 23:43:44 -080059#include <linux/dmapool.h>
Brett Russ20f733e2005-09-01 18:26:17 -040060#include <linux/dma-mapping.h>
Jeff Garzika9524a72005-10-30 14:39:11 -050061#include <linux/device.h>
Saeed Bisharac77a2f42009-12-06 18:26:18 +020062#include <linux/clk.h>
Saeed Bisharaf351b2d2008-02-01 18:08:03 -050063#include <linux/platform_device.h>
64#include <linux/ata_platform.h>
Lennert Buytenhek15a32632008-03-27 14:51:39 -040065#include <linux/mbus.h>
Mark Lordc46938c2008-05-02 14:02:28 -040066#include <linux/bitops.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090067#include <linux/gfp.h>
Andrew Lunn97b414e2012-06-10 16:45:37 +020068#include <linux/of.h>
69#include <linux/of_irq.h>
Brett Russ20f733e2005-09-01 18:26:17 -040070#include <scsi/scsi_host.h>
Jeff Garzik193515d2005-11-07 00:59:37 -050071#include <scsi/scsi_cmnd.h>
Jeff Garzik6c087722007-10-12 00:16:23 -040072#include <scsi/scsi_device.h>
Brett Russ20f733e2005-09-01 18:26:17 -040073#include <linux/libata.h>
Brett Russ20f733e2005-09-01 18:26:17 -040074
75#define DRV_NAME "sata_mv"
Mark Lordcae5a292009-04-06 16:43:45 -040076#define DRV_VERSION "1.28"
Brett Russ20f733e2005-09-01 18:26:17 -040077
Mark Lord40f21b12009-03-10 18:51:04 -040078/*
79 * module options
80 */
81
Mark Lord40f21b12009-03-10 18:51:04 -040082#ifdef CONFIG_PCI
Andrew Lunn13b74082012-09-28 17:04:10 +020083static int msi;
Mark Lord40f21b12009-03-10 18:51:04 -040084module_param(msi, int, S_IRUGO);
85MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
86#endif
87
Mark Lord2b748a02009-03-10 22:01:17 -040088static int irq_coalescing_io_count;
89module_param(irq_coalescing_io_count, int, S_IRUGO);
90MODULE_PARM_DESC(irq_coalescing_io_count,
91 "IRQ coalescing I/O count threshold (0..255)");
92
93static int irq_coalescing_usecs;
94module_param(irq_coalescing_usecs, int, S_IRUGO);
95MODULE_PARM_DESC(irq_coalescing_usecs,
96 "IRQ coalescing time threshold in usecs");
97
Brett Russ20f733e2005-09-01 18:26:17 -040098enum {
99 /* BAR's are enumerated in terms of pci_resource_start() terms */
100 MV_PRIMARY_BAR = 0, /* offset 0x10: memory space */
101 MV_IO_BAR = 2, /* offset 0x18: IO space */
102 MV_MISC_BAR = 3, /* offset 0x1c: FLASH, NVRAM, SRAM */
103
104 MV_MAJOR_REG_AREA_SZ = 0x10000, /* 64KB */
105 MV_MINOR_REG_AREA_SZ = 0x2000, /* 8KB */
106
Mark Lord2b748a02009-03-10 22:01:17 -0400107 /* For use with both IRQ coalescing methods ("all ports" or "per-HC" */
108 COAL_CLOCKS_PER_USEC = 150, /* for calculating COAL_TIMEs */
109 MAX_COAL_TIME_THRESHOLD = ((1 << 24) - 1), /* internal clocks count */
110 MAX_COAL_IO_COUNT = 255, /* completed I/O count */
111
Brett Russ20f733e2005-09-01 18:26:17 -0400112 MV_PCI_REG_BASE = 0,
Mark Lord615ab952006-05-19 16:24:56 -0400113
Mark Lord2b748a02009-03-10 22:01:17 -0400114 /*
115 * Per-chip ("all ports") interrupt coalescing feature.
116 * This is only for GEN_II / GEN_IIE hardware.
117 *
118 * Coalescing defers the interrupt until either the IO_THRESHOLD
119 * (count of completed I/Os) is met, or the TIME_THRESHOLD is met.
120 */
Mark Lordcae5a292009-04-06 16:43:45 -0400121 COAL_REG_BASE = 0x18000,
122 IRQ_COAL_CAUSE = (COAL_REG_BASE + 0x08),
Mark Lord2b748a02009-03-10 22:01:17 -0400123 ALL_PORTS_COAL_IRQ = (1 << 4), /* all ports irq event */
124
Mark Lordcae5a292009-04-06 16:43:45 -0400125 IRQ_COAL_IO_THRESHOLD = (COAL_REG_BASE + 0xcc),
126 IRQ_COAL_TIME_THRESHOLD = (COAL_REG_BASE + 0xd0),
Mark Lord2b748a02009-03-10 22:01:17 -0400127
128 /*
129 * Registers for the (unused here) transaction coalescing feature:
130 */
Mark Lordcae5a292009-04-06 16:43:45 -0400131 TRAN_COAL_CAUSE_LO = (COAL_REG_BASE + 0x88),
132 TRAN_COAL_CAUSE_HI = (COAL_REG_BASE + 0x8c),
Mark Lord2b748a02009-03-10 22:01:17 -0400133
Mark Lordcae5a292009-04-06 16:43:45 -0400134 SATAHC0_REG_BASE = 0x20000,
135 FLASH_CTL = 0x1046c,
136 GPIO_PORT_CTL = 0x104f0,
137 RESET_CFG = 0x180d8,
Brett Russ20f733e2005-09-01 18:26:17 -0400138
139 MV_PCI_REG_SZ = MV_MAJOR_REG_AREA_SZ,
140 MV_SATAHC_REG_SZ = MV_MAJOR_REG_AREA_SZ,
141 MV_SATAHC_ARBTR_REG_SZ = MV_MINOR_REG_AREA_SZ, /* arbiter */
142 MV_PORT_REG_SZ = MV_MINOR_REG_AREA_SZ,
143
Brett Russ31961942005-09-30 01:36:00 -0400144 MV_MAX_Q_DEPTH = 32,
145 MV_MAX_Q_DEPTH_MASK = MV_MAX_Q_DEPTH - 1,
146
147 /* CRQB needs alignment on a 1KB boundary. Size == 1KB
148 * CRPB needs alignment on a 256B boundary. Size == 256B
Brett Russ31961942005-09-30 01:36:00 -0400149 * ePRD (SG) entries need alignment on a 16B boundary. Size == 16B
150 */
151 MV_CRQB_Q_SZ = (32 * MV_MAX_Q_DEPTH),
152 MV_CRPB_Q_SZ = (8 * MV_MAX_Q_DEPTH),
Mark Lordda2fa9b2008-01-26 18:32:45 -0500153 MV_MAX_SG_CT = 256,
Brett Russ31961942005-09-30 01:36:00 -0400154 MV_SG_TBL_SZ = (16 * MV_MAX_SG_CT),
Brett Russ31961942005-09-30 01:36:00 -0400155
Mark Lord352fab72008-04-19 14:43:42 -0400156 /* Determine hc from 0-7 port: hc = port >> MV_PORT_HC_SHIFT */
Brett Russ20f733e2005-09-01 18:26:17 -0400157 MV_PORT_HC_SHIFT = 2,
Mark Lord352fab72008-04-19 14:43:42 -0400158 MV_PORTS_PER_HC = (1 << MV_PORT_HC_SHIFT), /* 4 */
159 /* Determine hc port from 0-7 port: hardport = port & MV_PORT_MASK */
160 MV_PORT_MASK = (MV_PORTS_PER_HC - 1), /* 3 */
Brett Russ20f733e2005-09-01 18:26:17 -0400161
162 /* Host Flags */
163 MV_FLAG_DUAL_HC = (1 << 30), /* two SATA Host Controllers */
Saeed Bishara7bb3c522008-01-30 11:50:45 -1100164
Sergei Shtylyov9cbe0562011-02-04 22:05:48 +0300165 MV_COMMON_FLAGS = ATA_FLAG_SATA | ATA_FLAG_PIO_POLLING,
Mark Lordad3aef52008-05-14 09:21:43 -0400166
Mark Lord91b1a842009-01-30 18:46:39 -0500167 MV_GEN_I_FLAGS = MV_COMMON_FLAGS | ATA_FLAG_NO_ATAPI,
Brett Russ20f733e2005-09-01 18:26:17 -0400168
Mark Lord40f21b12009-03-10 18:51:04 -0400169 MV_GEN_II_FLAGS = MV_COMMON_FLAGS | ATA_FLAG_NCQ |
170 ATA_FLAG_PMP | ATA_FLAG_ACPI_SATA,
Mark Lord91b1a842009-01-30 18:46:39 -0500171
172 MV_GEN_IIE_FLAGS = MV_GEN_II_FLAGS | ATA_FLAG_AN,
Mark Lordad3aef52008-05-14 09:21:43 -0400173
Brett Russ31961942005-09-30 01:36:00 -0400174 CRQB_FLAG_READ = (1 << 0),
175 CRQB_TAG_SHIFT = 1,
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400176 CRQB_IOID_SHIFT = 6, /* CRQB Gen-II/IIE IO Id shift */
Mark Lorde12bef52008-03-31 19:33:56 -0400177 CRQB_PMP_SHIFT = 12, /* CRQB Gen-II/IIE PMP shift */
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400178 CRQB_HOSTQ_SHIFT = 17, /* CRQB Gen-II/IIE HostQueTag shift */
Brett Russ31961942005-09-30 01:36:00 -0400179 CRQB_CMD_ADDR_SHIFT = 8,
180 CRQB_CMD_CS = (0x2 << 11),
181 CRQB_CMD_LAST = (1 << 15),
182
183 CRPB_FLAG_STATUS_SHIFT = 8,
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400184 CRPB_IOID_SHIFT_6 = 5, /* CRPB Gen-II IO Id shift */
185 CRPB_IOID_SHIFT_7 = 7, /* CRPB Gen-IIE IO Id shift */
Brett Russ31961942005-09-30 01:36:00 -0400186
187 EPRD_FLAG_END_OF_TBL = (1 << 31),
188
Brett Russ20f733e2005-09-01 18:26:17 -0400189 /* PCI interface registers */
190
Mark Lordcae5a292009-04-06 16:43:45 -0400191 MV_PCI_COMMAND = 0xc00,
192 MV_PCI_COMMAND_MWRCOM = (1 << 4), /* PCI Master Write Combining */
193 MV_PCI_COMMAND_MRDTRIG = (1 << 7), /* PCI Master Read Trigger */
Brett Russ31961942005-09-30 01:36:00 -0400194
Mark Lordcae5a292009-04-06 16:43:45 -0400195 PCI_MAIN_CMD_STS = 0xd30,
Brett Russ20f733e2005-09-01 18:26:17 -0400196 STOP_PCI_MASTER = (1 << 2),
197 PCI_MASTER_EMPTY = (1 << 3),
198 GLOB_SFT_RST = (1 << 4),
199
Mark Lordcae5a292009-04-06 16:43:45 -0400200 MV_PCI_MODE = 0xd00,
Mark Lord8e7decd2008-05-02 02:07:51 -0400201 MV_PCI_MODE_MASK = 0x30,
202
Jeff Garzik522479f2005-11-12 22:14:02 -0500203 MV_PCI_EXP_ROM_BAR_CTL = 0xd2c,
204 MV_PCI_DISC_TIMER = 0xd04,
205 MV_PCI_MSI_TRIGGER = 0xc38,
206 MV_PCI_SERR_MASK = 0xc28,
Mark Lordcae5a292009-04-06 16:43:45 -0400207 MV_PCI_XBAR_TMOUT = 0x1d04,
Jeff Garzik522479f2005-11-12 22:14:02 -0500208 MV_PCI_ERR_LOW_ADDRESS = 0x1d40,
209 MV_PCI_ERR_HIGH_ADDRESS = 0x1d44,
210 MV_PCI_ERR_ATTRIBUTE = 0x1d48,
211 MV_PCI_ERR_COMMAND = 0x1d50,
212
Mark Lordcae5a292009-04-06 16:43:45 -0400213 PCI_IRQ_CAUSE = 0x1d58,
214 PCI_IRQ_MASK = 0x1d5c,
Brett Russ20f733e2005-09-01 18:26:17 -0400215 PCI_UNMASK_ALL_IRQS = 0x7fffff, /* bits 22-0 */
216
Mark Lordcae5a292009-04-06 16:43:45 -0400217 PCIE_IRQ_CAUSE = 0x1900,
218 PCIE_IRQ_MASK = 0x1910,
Mark Lord646a4da2008-01-26 18:30:37 -0500219 PCIE_UNMASK_ALL_IRQS = 0x40a, /* assorted bits */
Mark Lord02a121d2007-12-01 13:07:22 -0500220
Mark Lord7368f912008-04-25 11:24:24 -0400221 /* Host Controller Main Interrupt Cause/Mask registers (1 per-chip) */
Mark Lordcae5a292009-04-06 16:43:45 -0400222 PCI_HC_MAIN_IRQ_CAUSE = 0x1d60,
223 PCI_HC_MAIN_IRQ_MASK = 0x1d64,
224 SOC_HC_MAIN_IRQ_CAUSE = 0x20020,
225 SOC_HC_MAIN_IRQ_MASK = 0x20024,
Mark Lord40f21b12009-03-10 18:51:04 -0400226 ERR_IRQ = (1 << 0), /* shift by (2 * port #) */
227 DONE_IRQ = (1 << 1), /* shift by (2 * port #) */
Brett Russ20f733e2005-09-01 18:26:17 -0400228 HC0_IRQ_PEND = 0x1ff, /* bits 0-8 = HC0's ports */
229 HC_SHIFT = 9, /* bits 9-17 = HC1's ports */
Mark Lord2b748a02009-03-10 22:01:17 -0400230 DONE_IRQ_0_3 = 0x000000aa, /* DONE_IRQ ports 0,1,2,3 */
231 DONE_IRQ_4_7 = (DONE_IRQ_0_3 << HC_SHIFT), /* 4,5,6,7 */
Brett Russ20f733e2005-09-01 18:26:17 -0400232 PCI_ERR = (1 << 18),
Mark Lord40f21b12009-03-10 18:51:04 -0400233 TRAN_COAL_LO_DONE = (1 << 19), /* transaction coalescing */
234 TRAN_COAL_HI_DONE = (1 << 20), /* transaction coalescing */
235 PORTS_0_3_COAL_DONE = (1 << 8), /* HC0 IRQ coalescing */
236 PORTS_4_7_COAL_DONE = (1 << 17), /* HC1 IRQ coalescing */
237 ALL_PORTS_COAL_DONE = (1 << 21), /* GEN_II(E) IRQ coalescing */
Brett Russ20f733e2005-09-01 18:26:17 -0400238 GPIO_INT = (1 << 22),
239 SELF_INT = (1 << 23),
240 TWSI_INT = (1 << 24),
241 HC_MAIN_RSVD = (0x7f << 25), /* bits 31-25 */
Jeff Garzikfb621e22007-02-25 04:19:45 -0500242 HC_MAIN_RSVD_5 = (0x1fff << 19), /* bits 31-19 */
Mark Lorde12bef52008-03-31 19:33:56 -0400243 HC_MAIN_RSVD_SOC = (0x3fffffb << 6), /* bits 31-9, 7-6 */
Brett Russ20f733e2005-09-01 18:26:17 -0400244
245 /* SATAHC registers */
Mark Lordcae5a292009-04-06 16:43:45 -0400246 HC_CFG = 0x00,
Brett Russ20f733e2005-09-01 18:26:17 -0400247
Mark Lordcae5a292009-04-06 16:43:45 -0400248 HC_IRQ_CAUSE = 0x14,
Mark Lord352fab72008-04-19 14:43:42 -0400249 DMA_IRQ = (1 << 0), /* shift by port # */
250 HC_COAL_IRQ = (1 << 4), /* IRQ coalescing */
Brett Russ20f733e2005-09-01 18:26:17 -0400251 DEV_IRQ = (1 << 8), /* shift by port # */
252
Mark Lord2b748a02009-03-10 22:01:17 -0400253 /*
254 * Per-HC (Host-Controller) interrupt coalescing feature.
255 * This is present on all chip generations.
256 *
257 * Coalescing defers the interrupt until either the IO_THRESHOLD
258 * (count of completed I/Os) is met, or the TIME_THRESHOLD is met.
259 */
Mark Lordcae5a292009-04-06 16:43:45 -0400260 HC_IRQ_COAL_IO_THRESHOLD = 0x000c,
261 HC_IRQ_COAL_TIME_THRESHOLD = 0x0010,
Mark Lord2b748a02009-03-10 22:01:17 -0400262
Mark Lordcae5a292009-04-06 16:43:45 -0400263 SOC_LED_CTRL = 0x2c,
Mark Lord000b3442009-03-15 11:33:19 -0400264 SOC_LED_CTRL_BLINK = (1 << 0), /* Active LED blink */
265 SOC_LED_CTRL_ACT_PRESENCE = (1 << 2), /* Multiplex dev presence */
266 /* with dev activity LED */
267
Brett Russ20f733e2005-09-01 18:26:17 -0400268 /* Shadow block registers */
Mark Lordcae5a292009-04-06 16:43:45 -0400269 SHD_BLK = 0x100,
270 SHD_CTL_AST = 0x20, /* ofs from SHD_BLK */
Brett Russ20f733e2005-09-01 18:26:17 -0400271
272 /* SATA registers */
Mark Lordcae5a292009-04-06 16:43:45 -0400273 SATA_STATUS = 0x300, /* ctrl, err regs follow status */
274 SATA_ACTIVE = 0x350,
275 FIS_IRQ_CAUSE = 0x364,
276 FIS_IRQ_CAUSE_AN = (1 << 9), /* async notification */
Mark Lord17c5aab2008-04-16 14:56:51 -0400277
Mark Lordcae5a292009-04-06 16:43:45 -0400278 LTMODE = 0x30c, /* requires read-after-write */
Mark Lord17c5aab2008-04-16 14:56:51 -0400279 LTMODE_BIT8 = (1 << 8), /* unknown, but necessary */
280
Mark Lordcae5a292009-04-06 16:43:45 -0400281 PHY_MODE2 = 0x330,
Jeff Garzik47c2b672005-11-12 21:13:17 -0500282 PHY_MODE3 = 0x310,
Mark Lordcae5a292009-04-06 16:43:45 -0400283
284 PHY_MODE4 = 0x314, /* requires read-after-write */
Mark Lordba069e32008-05-31 16:46:34 -0400285 PHY_MODE4_CFG_MASK = 0x00000003, /* phy internal config field */
286 PHY_MODE4_CFG_VALUE = 0x00000001, /* phy internal config field */
287 PHY_MODE4_RSVD_ZEROS = 0x5de3fffa, /* Gen2e always write zeros */
288 PHY_MODE4_RSVD_ONES = 0x00000005, /* Gen2e always write ones */
289
Mark Lordcae5a292009-04-06 16:43:45 -0400290 SATA_IFCTL = 0x344,
291 SATA_TESTCTL = 0x348,
292 SATA_IFSTAT = 0x34c,
293 VENDOR_UNIQUE_FIS = 0x35c,
Mark Lord17c5aab2008-04-16 14:56:51 -0400294
Mark Lordcae5a292009-04-06 16:43:45 -0400295 FISCFG = 0x360,
Mark Lord8e7decd2008-05-02 02:07:51 -0400296 FISCFG_WAIT_DEV_ERR = (1 << 8), /* wait for host on DevErr */
297 FISCFG_SINGLE_SYNC = (1 << 16), /* SYNC on DMA activation */
Mark Lord17c5aab2008-04-16 14:56:51 -0400298
Martin Michlmayr29b7e432009-05-04 20:58:50 +0200299 PHY_MODE9_GEN2 = 0x398,
300 PHY_MODE9_GEN1 = 0x39c,
301 PHYCFG_OFS = 0x3a0, /* only in 65n devices */
302
Jeff Garzikc9d39132005-11-13 17:47:51 -0500303 MV5_PHY_MODE = 0x74,
Mark Lordcae5a292009-04-06 16:43:45 -0400304 MV5_LTMODE = 0x30,
305 MV5_PHY_CTL = 0x0C,
306 SATA_IFCFG = 0x050,
Jeff Garzikbca1c4e2005-11-12 12:48:15 -0500307
308 MV_M2_PREAMP_MASK = 0x7e0,
Brett Russ20f733e2005-09-01 18:26:17 -0400309
310 /* Port registers */
Mark Lordcae5a292009-04-06 16:43:45 -0400311 EDMA_CFG = 0,
Mark Lord0c589122008-01-26 18:31:16 -0500312 EDMA_CFG_Q_DEPTH = 0x1f, /* max device queue depth */
313 EDMA_CFG_NCQ = (1 << 5), /* for R/W FPDMA queued */
314 EDMA_CFG_NCQ_GO_ON_ERR = (1 << 14), /* continue on error */
315 EDMA_CFG_RD_BRST_EXT = (1 << 11), /* read burst 512B */
316 EDMA_CFG_WR_BUFF_LEN = (1 << 13), /* write buffer 512B */
Mark Lorde12bef52008-03-31 19:33:56 -0400317 EDMA_CFG_EDMA_FBS = (1 << 16), /* EDMA FIS-Based Switching */
318 EDMA_CFG_FBS = (1 << 26), /* FIS-Based Switching */
Brett Russ20f733e2005-09-01 18:26:17 -0400319
Mark Lordcae5a292009-04-06 16:43:45 -0400320 EDMA_ERR_IRQ_CAUSE = 0x8,
321 EDMA_ERR_IRQ_MASK = 0xc,
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400322 EDMA_ERR_D_PAR = (1 << 0), /* UDMA data parity err */
323 EDMA_ERR_PRD_PAR = (1 << 1), /* UDMA PRD parity err */
324 EDMA_ERR_DEV = (1 << 2), /* device error */
325 EDMA_ERR_DEV_DCON = (1 << 3), /* device disconnect */
326 EDMA_ERR_DEV_CON = (1 << 4), /* device connected */
327 EDMA_ERR_SERR = (1 << 5), /* SError bits [WBDST] raised */
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400328 EDMA_ERR_SELF_DIS = (1 << 7), /* Gen II/IIE self-disable */
329 EDMA_ERR_SELF_DIS_5 = (1 << 8), /* Gen I self-disable */
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400330 EDMA_ERR_BIST_ASYNC = (1 << 8), /* BIST FIS or Async Notify */
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400331 EDMA_ERR_TRANS_IRQ_7 = (1 << 8), /* Gen IIE transprt layer irq */
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400332 EDMA_ERR_CRQB_PAR = (1 << 9), /* CRQB parity error */
333 EDMA_ERR_CRPB_PAR = (1 << 10), /* CRPB parity error */
334 EDMA_ERR_INTRL_PAR = (1 << 11), /* internal parity error */
335 EDMA_ERR_IORDY = (1 << 12), /* IORdy timeout */
Mark Lord646a4da2008-01-26 18:30:37 -0500336
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400337 EDMA_ERR_LNK_CTRL_RX = (0xf << 13), /* link ctrl rx error */
Mark Lord646a4da2008-01-26 18:30:37 -0500338 EDMA_ERR_LNK_CTRL_RX_0 = (1 << 13), /* transient: CRC err */
339 EDMA_ERR_LNK_CTRL_RX_1 = (1 << 14), /* transient: FIFO err */
340 EDMA_ERR_LNK_CTRL_RX_2 = (1 << 15), /* fatal: caught SYNC */
341 EDMA_ERR_LNK_CTRL_RX_3 = (1 << 16), /* transient: FIS rx err */
342
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400343 EDMA_ERR_LNK_DATA_RX = (0xf << 17), /* link data rx error */
Mark Lord646a4da2008-01-26 18:30:37 -0500344
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400345 EDMA_ERR_LNK_CTRL_TX = (0x1f << 21), /* link ctrl tx error */
Mark Lord646a4da2008-01-26 18:30:37 -0500346 EDMA_ERR_LNK_CTRL_TX_0 = (1 << 21), /* transient: CRC err */
347 EDMA_ERR_LNK_CTRL_TX_1 = (1 << 22), /* transient: FIFO err */
348 EDMA_ERR_LNK_CTRL_TX_2 = (1 << 23), /* transient: caught SYNC */
349 EDMA_ERR_LNK_CTRL_TX_3 = (1 << 24), /* transient: caught DMAT */
350 EDMA_ERR_LNK_CTRL_TX_4 = (1 << 25), /* transient: FIS collision */
351
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400352 EDMA_ERR_LNK_DATA_TX = (0x1f << 26), /* link data tx error */
Mark Lord646a4da2008-01-26 18:30:37 -0500353
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400354 EDMA_ERR_TRANS_PROTO = (1 << 31), /* transport protocol error */
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400355 EDMA_ERR_OVERRUN_5 = (1 << 5),
356 EDMA_ERR_UNDERRUN_5 = (1 << 6),
Mark Lord646a4da2008-01-26 18:30:37 -0500357
358 EDMA_ERR_IRQ_TRANSIENT = EDMA_ERR_LNK_CTRL_RX_0 |
359 EDMA_ERR_LNK_CTRL_RX_1 |
360 EDMA_ERR_LNK_CTRL_RX_3 |
Mark Lord85afb932008-04-19 14:54:41 -0400361 EDMA_ERR_LNK_CTRL_TX,
Mark Lord646a4da2008-01-26 18:30:37 -0500362
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400363 EDMA_EH_FREEZE = EDMA_ERR_D_PAR |
364 EDMA_ERR_PRD_PAR |
365 EDMA_ERR_DEV_DCON |
366 EDMA_ERR_DEV_CON |
367 EDMA_ERR_SERR |
368 EDMA_ERR_SELF_DIS |
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400369 EDMA_ERR_CRQB_PAR |
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400370 EDMA_ERR_CRPB_PAR |
371 EDMA_ERR_INTRL_PAR |
372 EDMA_ERR_IORDY |
373 EDMA_ERR_LNK_CTRL_RX_2 |
374 EDMA_ERR_LNK_DATA_RX |
375 EDMA_ERR_LNK_DATA_TX |
376 EDMA_ERR_TRANS_PROTO,
Mark Lorde12bef52008-03-31 19:33:56 -0400377
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400378 EDMA_EH_FREEZE_5 = EDMA_ERR_D_PAR |
379 EDMA_ERR_PRD_PAR |
380 EDMA_ERR_DEV_DCON |
381 EDMA_ERR_DEV_CON |
382 EDMA_ERR_OVERRUN_5 |
383 EDMA_ERR_UNDERRUN_5 |
384 EDMA_ERR_SELF_DIS_5 |
Jeff Garzik6c1153e2007-07-13 15:20:15 -0400385 EDMA_ERR_CRQB_PAR |
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400386 EDMA_ERR_CRPB_PAR |
387 EDMA_ERR_INTRL_PAR |
388 EDMA_ERR_IORDY,
Brett Russ20f733e2005-09-01 18:26:17 -0400389
Mark Lordcae5a292009-04-06 16:43:45 -0400390 EDMA_REQ_Q_BASE_HI = 0x10,
391 EDMA_REQ_Q_IN_PTR = 0x14, /* also contains BASE_LO */
Brett Russ31961942005-09-30 01:36:00 -0400392
Mark Lordcae5a292009-04-06 16:43:45 -0400393 EDMA_REQ_Q_OUT_PTR = 0x18,
Brett Russ31961942005-09-30 01:36:00 -0400394 EDMA_REQ_Q_PTR_SHIFT = 5,
395
Mark Lordcae5a292009-04-06 16:43:45 -0400396 EDMA_RSP_Q_BASE_HI = 0x1c,
397 EDMA_RSP_Q_IN_PTR = 0x20,
398 EDMA_RSP_Q_OUT_PTR = 0x24, /* also contains BASE_LO */
Brett Russ31961942005-09-30 01:36:00 -0400399 EDMA_RSP_Q_PTR_SHIFT = 3,
400
Mark Lordcae5a292009-04-06 16:43:45 -0400401 EDMA_CMD = 0x28, /* EDMA command register */
Jeff Garzik0ea9e172007-07-13 17:06:45 -0400402 EDMA_EN = (1 << 0), /* enable EDMA */
403 EDMA_DS = (1 << 1), /* disable EDMA; self-negated */
Mark Lord8e7decd2008-05-02 02:07:51 -0400404 EDMA_RESET = (1 << 2), /* reset eng/trans/link/phy */
Brett Russ20f733e2005-09-01 18:26:17 -0400405
Mark Lordcae5a292009-04-06 16:43:45 -0400406 EDMA_STATUS = 0x30, /* EDMA engine status */
Mark Lord8e7decd2008-05-02 02:07:51 -0400407 EDMA_STATUS_CACHE_EMPTY = (1 << 6), /* GenIIe command cache empty */
408 EDMA_STATUS_IDLE = (1 << 7), /* GenIIe EDMA enabled/idle */
409
Mark Lordcae5a292009-04-06 16:43:45 -0400410 EDMA_IORDY_TMOUT = 0x34,
411 EDMA_ARB_CFG = 0x38,
Mark Lord8e7decd2008-05-02 02:07:51 -0400412
Mark Lordcae5a292009-04-06 16:43:45 -0400413 EDMA_HALTCOND = 0x60, /* GenIIe halt conditions */
414 EDMA_UNKNOWN_RSVD = 0x6C, /* GenIIe unknown/reserved */
Mark Lordda142652009-01-30 18:51:54 -0500415
Mark Lordcae5a292009-04-06 16:43:45 -0400416 BMDMA_CMD = 0x224, /* bmdma command register */
417 BMDMA_STATUS = 0x228, /* bmdma status register */
418 BMDMA_PRD_LOW = 0x22c, /* bmdma PRD addr 31:0 */
419 BMDMA_PRD_HIGH = 0x230, /* bmdma PRD addr 63:32 */
Mark Lordda142652009-01-30 18:51:54 -0500420
Brett Russ31961942005-09-30 01:36:00 -0400421 /* Host private flags (hp_flags) */
422 MV_HP_FLAG_MSI = (1 << 0),
Jeff Garzik47c2b672005-11-12 21:13:17 -0500423 MV_HP_ERRATA_50XXB0 = (1 << 1),
424 MV_HP_ERRATA_50XXB2 = (1 << 2),
425 MV_HP_ERRATA_60X1B2 = (1 << 3),
426 MV_HP_ERRATA_60X1C0 = (1 << 4),
Jeff Garzik0ea9e172007-07-13 17:06:45 -0400427 MV_HP_GEN_I = (1 << 6), /* Generation I: 50xx */
428 MV_HP_GEN_II = (1 << 7), /* Generation II: 60xx */
429 MV_HP_GEN_IIE = (1 << 8), /* Generation IIE: 6042/7042 */
Mark Lord02a121d2007-12-01 13:07:22 -0500430 MV_HP_PCIE = (1 << 9), /* PCIe bus/regs: 7042 */
Mark Lord616d4a92008-05-02 02:08:32 -0400431 MV_HP_CUT_THROUGH = (1 << 10), /* can use EDMA cut-through */
Mark Lord1f398472008-05-27 17:54:48 -0400432 MV_HP_FLAG_SOC = (1 << 11), /* SystemOnChip, no PCI */
Mark Lord000b3442009-03-15 11:33:19 -0400433 MV_HP_QUIRK_LED_BLINK_EN = (1 << 12), /* is led blinking enabled? */
Brett Russ20f733e2005-09-01 18:26:17 -0400434
Brett Russ31961942005-09-30 01:36:00 -0400435 /* Port private flags (pp_flags) */
Jeff Garzik0ea9e172007-07-13 17:06:45 -0400436 MV_PP_FLAG_EDMA_EN = (1 << 0), /* is EDMA engine enabled? */
Mark Lord72109162008-01-26 18:31:33 -0500437 MV_PP_FLAG_NCQ_EN = (1 << 1), /* is EDMA set up for NCQ? */
Mark Lord00f42ea2008-05-02 02:11:45 -0400438 MV_PP_FLAG_FBS_EN = (1 << 2), /* is EDMA set up for FBS? */
Mark Lord29d187b2008-05-02 02:15:37 -0400439 MV_PP_FLAG_DELAYED_EH = (1 << 3), /* delayed dev err handling */
Mark Lordd16ab3f2009-02-25 15:17:43 -0500440 MV_PP_FLAG_FAKE_ATA_BUSY = (1 << 4), /* ignore initial ATA_DRDY */
Brett Russ31961942005-09-30 01:36:00 -0400441};
442
Jeff Garzikee9ccdf2007-07-12 15:51:22 -0400443#define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
444#define IS_GEN_II(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_II)
Jeff Garzike4e7b892006-01-31 12:18:41 -0500445#define IS_GEN_IIE(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_IIE)
Mark Lord8e7decd2008-05-02 02:07:51 -0400446#define IS_PCIE(hpriv) ((hpriv)->hp_flags & MV_HP_PCIE)
Mark Lord1f398472008-05-27 17:54:48 -0400447#define IS_SOC(hpriv) ((hpriv)->hp_flags & MV_HP_FLAG_SOC)
Jeff Garzikbca1c4e2005-11-12 12:48:15 -0500448
Lennert Buytenhek15a32632008-03-27 14:51:39 -0400449#define WINDOW_CTRL(i) (0x20030 + ((i) << 4))
450#define WINDOW_BASE(i) (0x20034 + ((i) << 4))
451
Jeff Garzik095fec82005-11-12 09:50:49 -0500452enum {
Jeff Garzikbaf14aa2007-10-09 13:51:57 -0400453 /* DMA boundary 0xffff is required by the s/g splitting
454 * we need on /length/ in mv_fill-sg().
455 */
456 MV_DMA_BOUNDARY = 0xffffU,
Jeff Garzik095fec82005-11-12 09:50:49 -0500457
Jeff Garzik0ea9e172007-07-13 17:06:45 -0400458 /* mask of register bits containing lower 32 bits
459 * of EDMA request queue DMA address
460 */
Jeff Garzik095fec82005-11-12 09:50:49 -0500461 EDMA_REQ_Q_BASE_LO_MASK = 0xfffffc00U,
462
Jeff Garzik0ea9e172007-07-13 17:06:45 -0400463 /* ditto, for response queue */
Jeff Garzik095fec82005-11-12 09:50:49 -0500464 EDMA_RSP_Q_BASE_LO_MASK = 0xffffff00U,
465};
466
Jeff Garzik522479f2005-11-12 22:14:02 -0500467enum chip_type {
468 chip_504x,
469 chip_508x,
470 chip_5080,
471 chip_604x,
472 chip_608x,
Jeff Garzike4e7b892006-01-31 12:18:41 -0500473 chip_6042,
474 chip_7042,
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500475 chip_soc,
Jeff Garzik522479f2005-11-12 22:14:02 -0500476};
477
Brett Russ31961942005-09-30 01:36:00 -0400478/* Command ReQuest Block: 32B */
479struct mv_crqb {
Mark Lorde1469872006-05-22 19:02:03 -0400480 __le32 sg_addr;
481 __le32 sg_addr_hi;
482 __le16 ctrl_flags;
483 __le16 ata_cmd[11];
Brett Russ31961942005-09-30 01:36:00 -0400484};
485
Jeff Garzike4e7b892006-01-31 12:18:41 -0500486struct mv_crqb_iie {
Mark Lorde1469872006-05-22 19:02:03 -0400487 __le32 addr;
488 __le32 addr_hi;
489 __le32 flags;
490 __le32 len;
491 __le32 ata_cmd[4];
Jeff Garzike4e7b892006-01-31 12:18:41 -0500492};
493
Brett Russ31961942005-09-30 01:36:00 -0400494/* Command ResPonse Block: 8B */
495struct mv_crpb {
Mark Lorde1469872006-05-22 19:02:03 -0400496 __le16 id;
497 __le16 flags;
498 __le32 tmstmp;
Brett Russ31961942005-09-30 01:36:00 -0400499};
500
501/* EDMA Physical Region Descriptor (ePRD); A.K.A. SG */
502struct mv_sg {
Mark Lorde1469872006-05-22 19:02:03 -0400503 __le32 addr;
504 __le32 flags_size;
505 __le32 addr_hi;
506 __le32 reserved;
Brett Russ20f733e2005-09-01 18:26:17 -0400507};
508
Mark Lord08da1752009-02-25 15:13:03 -0500509/*
510 * We keep a local cache of a few frequently accessed port
511 * registers here, to avoid having to read them (very slow)
512 * when switching between EDMA and non-EDMA modes.
513 */
514struct mv_cached_regs {
515 u32 fiscfg;
516 u32 ltmode;
517 u32 haltcond;
Mark Lordc01e8a22009-02-25 15:14:48 -0500518 u32 unknown_rsvd;
Mark Lord08da1752009-02-25 15:13:03 -0500519};
520
Brett Russ20f733e2005-09-01 18:26:17 -0400521struct mv_port_priv {
Brett Russ31961942005-09-30 01:36:00 -0400522 struct mv_crqb *crqb;
523 dma_addr_t crqb_dma;
524 struct mv_crpb *crpb;
525 dma_addr_t crpb_dma;
Mark Lordeb73d552008-01-29 13:24:00 -0500526 struct mv_sg *sg_tbl[MV_MAX_Q_DEPTH];
527 dma_addr_t sg_tbl_dma[MV_MAX_Q_DEPTH];
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400528
529 unsigned int req_idx;
530 unsigned int resp_idx;
531
Brett Russ31961942005-09-30 01:36:00 -0400532 u32 pp_flags;
Mark Lord08da1752009-02-25 15:13:03 -0500533 struct mv_cached_regs cached;
Mark Lord29d187b2008-05-02 02:15:37 -0400534 unsigned int delayed_eh_pmp_map;
Brett Russ20f733e2005-09-01 18:26:17 -0400535};
536
Jeff Garzikbca1c4e2005-11-12 12:48:15 -0500537struct mv_port_signal {
538 u32 amps;
539 u32 pre;
540};
541
Mark Lord02a121d2007-12-01 13:07:22 -0500542struct mv_host_priv {
543 u32 hp_flags;
Saeed Bishara1bfeff02009-12-17 01:05:00 -0500544 unsigned int board_idx;
Mark Lord96e2c4872008-05-17 13:38:00 -0400545 u32 main_irq_mask;
Mark Lord02a121d2007-12-01 13:07:22 -0500546 struct mv_port_signal signal[8];
547 const struct mv_hw_ops *ops;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500548 int n_ports;
549 void __iomem *base;
Mark Lord7368f912008-04-25 11:24:24 -0400550 void __iomem *main_irq_cause_addr;
551 void __iomem *main_irq_mask_addr;
Mark Lordcae5a292009-04-06 16:43:45 -0400552 u32 irq_cause_offset;
553 u32 irq_mask_offset;
Mark Lord02a121d2007-12-01 13:07:22 -0500554 u32 unmask_all_irqs;
Saeed Bisharac77a2f42009-12-06 18:26:18 +0200555
Ezequiel Garciae0067f02013-07-29 23:46:03 -0300556 /*
557 * Needed on some devices that require their clocks to be enabled.
558 * These are optional: if the platform device does not have any
559 * clocks, they won't be used. Also, if the underlying hardware
560 * does not support the common clock framework (CONFIG_HAVE_CLK=n),
561 * all the clock operations become no-ops (see clk.h).
562 */
Saeed Bisharac77a2f42009-12-06 18:26:18 +0200563 struct clk *clk;
Andrew Lunneee98992012-02-18 22:26:42 +0100564 struct clk **port_clks;
Mark Lordda2fa9b2008-01-26 18:32:45 -0500565 /*
566 * These consistent DMA memory pools give us guaranteed
567 * alignment for hardware-accessed data structures,
568 * and less memory waste in accomplishing the alignment.
569 */
570 struct dma_pool *crqb_pool;
571 struct dma_pool *crpb_pool;
572 struct dma_pool *sg_tbl_pool;
Mark Lord02a121d2007-12-01 13:07:22 -0500573};
574
Jeff Garzik47c2b672005-11-12 21:13:17 -0500575struct mv_hw_ops {
Jeff Garzik2a47ce02005-11-12 23:05:14 -0500576 void (*phy_errata)(struct mv_host_priv *hpriv, void __iomem *mmio,
577 unsigned int port);
Jeff Garzik47c2b672005-11-12 21:13:17 -0500578 void (*enable_leds)(struct mv_host_priv *hpriv, void __iomem *mmio);
579 void (*read_preamp)(struct mv_host_priv *hpriv, int idx,
580 void __iomem *mmio);
Jeff Garzikc9d39132005-11-13 17:47:51 -0500581 int (*reset_hc)(struct mv_host_priv *hpriv, void __iomem *mmio,
582 unsigned int n_hc);
Jeff Garzik522479f2005-11-12 22:14:02 -0500583 void (*reset_flash)(struct mv_host_priv *hpriv, void __iomem *mmio);
Saeed Bishara7bb3c522008-01-30 11:50:45 -1100584 void (*reset_bus)(struct ata_host *host, void __iomem *mmio);
Jeff Garzik47c2b672005-11-12 21:13:17 -0500585};
586
Tejun Heo82ef04f2008-07-31 17:02:40 +0900587static int mv_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val);
588static int mv_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val);
589static int mv5_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val);
590static int mv5_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val);
Brett Russ31961942005-09-30 01:36:00 -0400591static int mv_port_start(struct ata_port *ap);
592static void mv_port_stop(struct ata_port *ap);
Mark Lord3e4a1392008-05-02 02:10:02 -0400593static int mv_qc_defer(struct ata_queued_cmd *qc);
Brett Russ31961942005-09-30 01:36:00 -0400594static void mv_qc_prep(struct ata_queued_cmd *qc);
Jeff Garzike4e7b892006-01-31 12:18:41 -0500595static void mv_qc_prep_iie(struct ata_queued_cmd *qc);
Tejun Heo9a3d9eb2006-01-23 13:09:36 +0900596static unsigned int mv_qc_issue(struct ata_queued_cmd *qc);
Tejun Heoa1efdab2008-03-25 12:22:50 +0900597static int mv_hardreset(struct ata_link *link, unsigned int *class,
598 unsigned long deadline);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400599static void mv_eh_freeze(struct ata_port *ap);
600static void mv_eh_thaw(struct ata_port *ap);
Mark Lordf2738272008-01-26 18:32:29 -0500601static void mv6_dev_config(struct ata_device *dev);
Brett Russ20f733e2005-09-01 18:26:17 -0400602
Jeff Garzik2a47ce02005-11-12 23:05:14 -0500603static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
604 unsigned int port);
Jeff Garzik47c2b672005-11-12 21:13:17 -0500605static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
606static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
607 void __iomem *mmio);
Jeff Garzikc9d39132005-11-13 17:47:51 -0500608static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
609 unsigned int n_hc);
Jeff Garzik522479f2005-11-12 22:14:02 -0500610static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
Saeed Bishara7bb3c522008-01-30 11:50:45 -1100611static void mv5_reset_bus(struct ata_host *host, void __iomem *mmio);
Jeff Garzik47c2b672005-11-12 21:13:17 -0500612
Jeff Garzik2a47ce02005-11-12 23:05:14 -0500613static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
614 unsigned int port);
Jeff Garzik47c2b672005-11-12 21:13:17 -0500615static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
616static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
617 void __iomem *mmio);
Jeff Garzikc9d39132005-11-13 17:47:51 -0500618static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
619 unsigned int n_hc);
Jeff Garzik522479f2005-11-12 22:14:02 -0500620static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500621static void mv_soc_enable_leds(struct mv_host_priv *hpriv,
622 void __iomem *mmio);
623static void mv_soc_read_preamp(struct mv_host_priv *hpriv, int idx,
624 void __iomem *mmio);
625static int mv_soc_reset_hc(struct mv_host_priv *hpriv,
626 void __iomem *mmio, unsigned int n_hc);
627static void mv_soc_reset_flash(struct mv_host_priv *hpriv,
628 void __iomem *mmio);
629static void mv_soc_reset_bus(struct ata_host *host, void __iomem *mmio);
Martin Michlmayr29b7e432009-05-04 20:58:50 +0200630static void mv_soc_65n_phy_errata(struct mv_host_priv *hpriv,
631 void __iomem *mmio, unsigned int port);
Saeed Bishara7bb3c522008-01-30 11:50:45 -1100632static void mv_reset_pci_bus(struct ata_host *host, void __iomem *mmio);
Mark Lorde12bef52008-03-31 19:33:56 -0400633static void mv_reset_channel(struct mv_host_priv *hpriv, void __iomem *mmio,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500634 unsigned int port_no);
Mark Lorde12bef52008-03-31 19:33:56 -0400635static int mv_stop_edma(struct ata_port *ap);
Mark Lordb5624682008-03-31 19:34:40 -0400636static int mv_stop_edma_engine(void __iomem *port_mmio);
Mark Lord00b81232009-01-30 18:47:51 -0500637static void mv_edma_cfg(struct ata_port *ap, int want_ncq, int want_edma);
Jeff Garzik47c2b672005-11-12 21:13:17 -0500638
Mark Lorde49856d2008-04-16 14:59:07 -0400639static void mv_pmp_select(struct ata_port *ap, int pmp);
640static int mv_pmp_hardreset(struct ata_link *link, unsigned int *class,
641 unsigned long deadline);
642static int mv_softreset(struct ata_link *link, unsigned int *class,
643 unsigned long deadline);
Mark Lord29d187b2008-05-02 02:15:37 -0400644static void mv_pmp_error_handler(struct ata_port *ap);
Mark Lord4c299ca2008-05-02 02:16:20 -0400645static void mv_process_crpb_entries(struct ata_port *ap,
646 struct mv_port_priv *pp);
Brett Russ20f733e2005-09-01 18:26:17 -0400647
Mark Lordda142652009-01-30 18:51:54 -0500648static void mv_sff_irq_clear(struct ata_port *ap);
649static int mv_check_atapi_dma(struct ata_queued_cmd *qc);
650static void mv_bmdma_setup(struct ata_queued_cmd *qc);
651static void mv_bmdma_start(struct ata_queued_cmd *qc);
652static void mv_bmdma_stop(struct ata_queued_cmd *qc);
653static u8 mv_bmdma_status(struct ata_port *ap);
Mark Lordd16ab3f2009-02-25 15:17:43 -0500654static u8 mv_sff_check_status(struct ata_port *ap);
Mark Lordda142652009-01-30 18:51:54 -0500655
Mark Lordeb73d552008-01-29 13:24:00 -0500656/* .sg_tablesize is (MV_MAX_SG_CT / 2) in the structures below
657 * because we have to allow room for worst case splitting of
658 * PRDs for 64K boundaries in mv_fill_sg().
659 */
Andrew Lunn13b74082012-09-28 17:04:10 +0200660#ifdef CONFIG_PCI
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400661static struct scsi_host_template mv5_sht = {
Tejun Heo68d1d072008-03-25 12:22:49 +0900662 ATA_BASE_SHT(DRV_NAME),
Jeff Garzikbaf14aa2007-10-09 13:51:57 -0400663 .sg_tablesize = MV_MAX_SG_CT / 2,
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400664 .dma_boundary = MV_DMA_BOUNDARY,
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400665};
Andrew Lunn13b74082012-09-28 17:04:10 +0200666#endif
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400667static struct scsi_host_template mv6_sht = {
Tejun Heo68d1d072008-03-25 12:22:49 +0900668 ATA_NCQ_SHT(DRV_NAME),
Mark Lord138bfdd2008-01-26 18:33:18 -0500669 .can_queue = MV_MAX_Q_DEPTH - 1,
Jeff Garzikbaf14aa2007-10-09 13:51:57 -0400670 .sg_tablesize = MV_MAX_SG_CT / 2,
Brett Russ20f733e2005-09-01 18:26:17 -0400671 .dma_boundary = MV_DMA_BOUNDARY,
Brett Russ20f733e2005-09-01 18:26:17 -0400672};
673
Tejun Heo029cfd62008-03-25 12:22:49 +0900674static struct ata_port_operations mv5_ops = {
675 .inherits = &ata_sff_port_ops,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500676
Alan Coxc96f1732009-03-24 10:23:46 +0000677 .lost_interrupt = ATA_OP_NULL,
678
Mark Lord3e4a1392008-05-02 02:10:02 -0400679 .qc_defer = mv_qc_defer,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500680 .qc_prep = mv_qc_prep,
681 .qc_issue = mv_qc_issue,
682
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400683 .freeze = mv_eh_freeze,
684 .thaw = mv_eh_thaw,
Tejun Heoa1efdab2008-03-25 12:22:50 +0900685 .hardreset = mv_hardreset,
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400686
Jeff Garzikc9d39132005-11-13 17:47:51 -0500687 .scr_read = mv5_scr_read,
688 .scr_write = mv5_scr_write,
689
690 .port_start = mv_port_start,
691 .port_stop = mv_port_stop,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500692};
693
Tejun Heo029cfd62008-03-25 12:22:49 +0900694static struct ata_port_operations mv6_ops = {
Tejun Heo8930ff22010-05-10 21:41:33 +0200695 .inherits = &ata_bmdma_port_ops,
Brett Russ20f733e2005-09-01 18:26:17 -0400696
Tejun Heo8930ff22010-05-10 21:41:33 +0200697 .lost_interrupt = ATA_OP_NULL,
698
699 .qc_defer = mv_qc_defer,
700 .qc_prep = mv_qc_prep,
701 .qc_issue = mv_qc_issue,
702
703 .dev_config = mv6_dev_config,
704
705 .freeze = mv_eh_freeze,
706 .thaw = mv_eh_thaw,
707 .hardreset = mv_hardreset,
708 .softreset = mv_softreset,
Mark Lorde49856d2008-04-16 14:59:07 -0400709 .pmp_hardreset = mv_pmp_hardreset,
710 .pmp_softreset = mv_softreset,
Mark Lord29d187b2008-05-02 02:15:37 -0400711 .error_handler = mv_pmp_error_handler,
Mark Lordda142652009-01-30 18:51:54 -0500712
Tejun Heo8930ff22010-05-10 21:41:33 +0200713 .scr_read = mv_scr_read,
714 .scr_write = mv_scr_write,
715
Mark Lord40f21b12009-03-10 18:51:04 -0400716 .sff_check_status = mv_sff_check_status,
Mark Lordda142652009-01-30 18:51:54 -0500717 .sff_irq_clear = mv_sff_irq_clear,
718 .check_atapi_dma = mv_check_atapi_dma,
719 .bmdma_setup = mv_bmdma_setup,
720 .bmdma_start = mv_bmdma_start,
721 .bmdma_stop = mv_bmdma_stop,
722 .bmdma_status = mv_bmdma_status,
Tejun Heo8930ff22010-05-10 21:41:33 +0200723
724 .port_start = mv_port_start,
725 .port_stop = mv_port_stop,
Brett Russ20f733e2005-09-01 18:26:17 -0400726};
727
Tejun Heo029cfd62008-03-25 12:22:49 +0900728static struct ata_port_operations mv_iie_ops = {
729 .inherits = &mv6_ops,
730 .dev_config = ATA_OP_NULL,
Jeff Garzike4e7b892006-01-31 12:18:41 -0500731 .qc_prep = mv_qc_prep_iie,
Jeff Garzike4e7b892006-01-31 12:18:41 -0500732};
733
Arjan van de Ven98ac62d2005-11-28 10:06:23 +0100734static const struct ata_port_info mv_port_info[] = {
Brett Russ20f733e2005-09-01 18:26:17 -0400735 { /* chip_504x */
Mark Lord91b1a842009-01-30 18:46:39 -0500736 .flags = MV_GEN_I_FLAGS,
Mark Lordc361acb2009-04-06 15:22:21 -0400737 .pio_mask = ATA_PIO4,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400738 .udma_mask = ATA_UDMA6,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500739 .port_ops = &mv5_ops,
Brett Russ20f733e2005-09-01 18:26:17 -0400740 },
741 { /* chip_508x */
Mark Lord91b1a842009-01-30 18:46:39 -0500742 .flags = MV_GEN_I_FLAGS | MV_FLAG_DUAL_HC,
Mark Lordc361acb2009-04-06 15:22:21 -0400743 .pio_mask = ATA_PIO4,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400744 .udma_mask = ATA_UDMA6,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500745 .port_ops = &mv5_ops,
Brett Russ20f733e2005-09-01 18:26:17 -0400746 },
Jeff Garzik47c2b672005-11-12 21:13:17 -0500747 { /* chip_5080 */
Mark Lord91b1a842009-01-30 18:46:39 -0500748 .flags = MV_GEN_I_FLAGS | MV_FLAG_DUAL_HC,
Mark Lordc361acb2009-04-06 15:22:21 -0400749 .pio_mask = ATA_PIO4,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400750 .udma_mask = ATA_UDMA6,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500751 .port_ops = &mv5_ops,
Jeff Garzik47c2b672005-11-12 21:13:17 -0500752 },
Brett Russ20f733e2005-09-01 18:26:17 -0400753 { /* chip_604x */
Mark Lord91b1a842009-01-30 18:46:39 -0500754 .flags = MV_GEN_II_FLAGS,
Mark Lordc361acb2009-04-06 15:22:21 -0400755 .pio_mask = ATA_PIO4,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400756 .udma_mask = ATA_UDMA6,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500757 .port_ops = &mv6_ops,
Brett Russ20f733e2005-09-01 18:26:17 -0400758 },
759 { /* chip_608x */
Mark Lord91b1a842009-01-30 18:46:39 -0500760 .flags = MV_GEN_II_FLAGS | MV_FLAG_DUAL_HC,
Mark Lordc361acb2009-04-06 15:22:21 -0400761 .pio_mask = ATA_PIO4,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400762 .udma_mask = ATA_UDMA6,
Jeff Garzikc9d39132005-11-13 17:47:51 -0500763 .port_ops = &mv6_ops,
Brett Russ20f733e2005-09-01 18:26:17 -0400764 },
Jeff Garzike4e7b892006-01-31 12:18:41 -0500765 { /* chip_6042 */
Mark Lord91b1a842009-01-30 18:46:39 -0500766 .flags = MV_GEN_IIE_FLAGS,
Mark Lordc361acb2009-04-06 15:22:21 -0400767 .pio_mask = ATA_PIO4,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400768 .udma_mask = ATA_UDMA6,
Jeff Garzike4e7b892006-01-31 12:18:41 -0500769 .port_ops = &mv_iie_ops,
770 },
771 { /* chip_7042 */
Mark Lord91b1a842009-01-30 18:46:39 -0500772 .flags = MV_GEN_IIE_FLAGS,
Mark Lordc361acb2009-04-06 15:22:21 -0400773 .pio_mask = ATA_PIO4,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400774 .udma_mask = ATA_UDMA6,
Jeff Garzike4e7b892006-01-31 12:18:41 -0500775 .port_ops = &mv_iie_ops,
776 },
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500777 { /* chip_soc */
Mark Lord91b1a842009-01-30 18:46:39 -0500778 .flags = MV_GEN_IIE_FLAGS,
Mark Lordc361acb2009-04-06 15:22:21 -0400779 .pio_mask = ATA_PIO4,
Mark Lord17c5aab2008-04-16 14:56:51 -0400780 .udma_mask = ATA_UDMA6,
781 .port_ops = &mv_iie_ops,
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500782 },
Brett Russ20f733e2005-09-01 18:26:17 -0400783};
784
Jeff Garzik3b7d6972005-11-10 11:04:11 -0500785static const struct pci_device_id mv_pci_tbl[] = {
Jeff Garzik2d2744f2006-09-28 20:21:59 -0400786 { PCI_VDEVICE(MARVELL, 0x5040), chip_504x },
787 { PCI_VDEVICE(MARVELL, 0x5041), chip_504x },
788 { PCI_VDEVICE(MARVELL, 0x5080), chip_5080 },
789 { PCI_VDEVICE(MARVELL, 0x5081), chip_508x },
Mark Lord46c57842008-09-04 18:21:07 -0400790 /* RocketRAID 1720/174x have different identifiers */
791 { PCI_VDEVICE(TTI, 0x1720), chip_6042 },
Mark Lord44622542009-01-27 16:33:13 -0500792 { PCI_VDEVICE(TTI, 0x1740), chip_6042 },
793 { PCI_VDEVICE(TTI, 0x1742), chip_6042 },
Brett Russ20f733e2005-09-01 18:26:17 -0400794
Jeff Garzik2d2744f2006-09-28 20:21:59 -0400795 { PCI_VDEVICE(MARVELL, 0x6040), chip_604x },
796 { PCI_VDEVICE(MARVELL, 0x6041), chip_604x },
797 { PCI_VDEVICE(MARVELL, 0x6042), chip_6042 },
798 { PCI_VDEVICE(MARVELL, 0x6080), chip_608x },
799 { PCI_VDEVICE(MARVELL, 0x6081), chip_608x },
Jeff Garzik29179532005-11-11 08:08:03 -0500800
Jeff Garzik2d2744f2006-09-28 20:21:59 -0400801 { PCI_VDEVICE(ADAPTEC2, 0x0241), chip_604x },
802
Florian Attenbergerd9f9c6b2007-07-02 17:09:29 +0200803 /* Adaptec 1430SA */
804 { PCI_VDEVICE(ADAPTEC2, 0x0243), chip_7042 },
805
Mark Lord02a121d2007-12-01 13:07:22 -0500806 /* Marvell 7042 support */
Morrison, Tom6a3d5862007-03-06 02:38:10 -0800807 { PCI_VDEVICE(MARVELL, 0x7042), chip_7042 },
808
Mark Lord02a121d2007-12-01 13:07:22 -0500809 /* Highpoint RocketRAID PCIe series */
810 { PCI_VDEVICE(TTI, 0x2300), chip_7042 },
811 { PCI_VDEVICE(TTI, 0x2310), chip_7042 },
812
Jeff Garzik2d2744f2006-09-28 20:21:59 -0400813 { } /* terminate list */
Brett Russ20f733e2005-09-01 18:26:17 -0400814};
815
Jeff Garzik47c2b672005-11-12 21:13:17 -0500816static const struct mv_hw_ops mv5xxx_ops = {
817 .phy_errata = mv5_phy_errata,
818 .enable_leds = mv5_enable_leds,
819 .read_preamp = mv5_read_preamp,
820 .reset_hc = mv5_reset_hc,
Jeff Garzik522479f2005-11-12 22:14:02 -0500821 .reset_flash = mv5_reset_flash,
822 .reset_bus = mv5_reset_bus,
Jeff Garzik47c2b672005-11-12 21:13:17 -0500823};
824
825static const struct mv_hw_ops mv6xxx_ops = {
826 .phy_errata = mv6_phy_errata,
827 .enable_leds = mv6_enable_leds,
828 .read_preamp = mv6_read_preamp,
829 .reset_hc = mv6_reset_hc,
Jeff Garzik522479f2005-11-12 22:14:02 -0500830 .reset_flash = mv6_reset_flash,
831 .reset_bus = mv_reset_pci_bus,
Jeff Garzik47c2b672005-11-12 21:13:17 -0500832};
833
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500834static const struct mv_hw_ops mv_soc_ops = {
835 .phy_errata = mv6_phy_errata,
836 .enable_leds = mv_soc_enable_leds,
837 .read_preamp = mv_soc_read_preamp,
838 .reset_hc = mv_soc_reset_hc,
839 .reset_flash = mv_soc_reset_flash,
840 .reset_bus = mv_soc_reset_bus,
841};
842
Martin Michlmayr29b7e432009-05-04 20:58:50 +0200843static const struct mv_hw_ops mv_soc_65n_ops = {
844 .phy_errata = mv_soc_65n_phy_errata,
845 .enable_leds = mv_soc_enable_leds,
846 .reset_hc = mv_soc_reset_hc,
847 .reset_flash = mv_soc_reset_flash,
848 .reset_bus = mv_soc_reset_bus,
849};
850
Brett Russ20f733e2005-09-01 18:26:17 -0400851/*
852 * Functions
853 */
854
855static inline void writelfl(unsigned long data, void __iomem *addr)
856{
857 writel(data, addr);
858 (void) readl(addr); /* flush to avoid PCI posted write */
859}
860
Jeff Garzikc9d39132005-11-13 17:47:51 -0500861static inline unsigned int mv_hc_from_port(unsigned int port)
862{
863 return port >> MV_PORT_HC_SHIFT;
864}
865
866static inline unsigned int mv_hardport_from_port(unsigned int port)
867{
868 return port & MV_PORT_MASK;
869}
870
Mark Lord1cfd19a2008-04-19 15:05:50 -0400871/*
872 * Consolidate some rather tricky bit shift calculations.
873 * This is hot-path stuff, so not a function.
874 * Simple code, with two return values, so macro rather than inline.
875 *
876 * port is the sole input, in range 0..7.
Mark Lord7368f912008-04-25 11:24:24 -0400877 * shift is one output, for use with main_irq_cause / main_irq_mask registers.
878 * hardport is the other output, in range 0..3.
Mark Lord1cfd19a2008-04-19 15:05:50 -0400879 *
880 * Note that port and hardport may be the same variable in some cases.
881 */
882#define MV_PORT_TO_SHIFT_AND_HARDPORT(port, shift, hardport) \
883{ \
884 shift = mv_hc_from_port(port) * HC_SHIFT; \
885 hardport = mv_hardport_from_port(port); \
886 shift += hardport * 2; \
887}
888
Mark Lord352fab72008-04-19 14:43:42 -0400889static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
890{
Mark Lordcae5a292009-04-06 16:43:45 -0400891 return (base + SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
Mark Lord352fab72008-04-19 14:43:42 -0400892}
893
Jeff Garzikc9d39132005-11-13 17:47:51 -0500894static inline void __iomem *mv_hc_base_from_port(void __iomem *base,
895 unsigned int port)
896{
897 return mv_hc_base(base, mv_hc_from_port(port));
898}
899
Brett Russ20f733e2005-09-01 18:26:17 -0400900static inline void __iomem *mv_port_base(void __iomem *base, unsigned int port)
901{
Jeff Garzikc9d39132005-11-13 17:47:51 -0500902 return mv_hc_base_from_port(base, port) +
Jeff Garzik8b260242005-11-12 12:32:50 -0500903 MV_SATAHC_ARBTR_REG_SZ +
Jeff Garzikc9d39132005-11-13 17:47:51 -0500904 (mv_hardport_from_port(port) * MV_PORT_REG_SZ);
Brett Russ20f733e2005-09-01 18:26:17 -0400905}
906
Mark Lorde12bef52008-03-31 19:33:56 -0400907static void __iomem *mv5_phy_base(void __iomem *mmio, unsigned int port)
908{
909 void __iomem *hc_mmio = mv_hc_base_from_port(mmio, port);
910 unsigned long ofs = (mv_hardport_from_port(port) + 1) * 0x100UL;
911
912 return hc_mmio + ofs;
913}
914
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500915static inline void __iomem *mv_host_base(struct ata_host *host)
916{
917 struct mv_host_priv *hpriv = host->private_data;
918 return hpriv->base;
919}
920
Brett Russ20f733e2005-09-01 18:26:17 -0400921static inline void __iomem *mv_ap_base(struct ata_port *ap)
922{
Saeed Bisharaf351b2d2008-02-01 18:08:03 -0500923 return mv_port_base(mv_host_base(ap->host), ap->port_no);
Brett Russ20f733e2005-09-01 18:26:17 -0400924}
925
Jeff Garzikcca39742006-08-24 03:19:22 -0400926static inline int mv_get_hc_count(unsigned long port_flags)
Brett Russ20f733e2005-09-01 18:26:17 -0400927{
Jeff Garzikcca39742006-08-24 03:19:22 -0400928 return ((port_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
Brett Russ20f733e2005-09-01 18:26:17 -0400929}
930
Mark Lord08da1752009-02-25 15:13:03 -0500931/**
932 * mv_save_cached_regs - (re-)initialize cached port registers
933 * @ap: the port whose registers we are caching
934 *
935 * Initialize the local cache of port registers,
936 * so that reading them over and over again can
937 * be avoided on the hotter paths of this driver.
938 * This saves a few microseconds each time we switch
939 * to/from EDMA mode to perform (eg.) a drive cache flush.
940 */
941static void mv_save_cached_regs(struct ata_port *ap)
942{
943 void __iomem *port_mmio = mv_ap_base(ap);
944 struct mv_port_priv *pp = ap->private_data;
945
Mark Lordcae5a292009-04-06 16:43:45 -0400946 pp->cached.fiscfg = readl(port_mmio + FISCFG);
947 pp->cached.ltmode = readl(port_mmio + LTMODE);
948 pp->cached.haltcond = readl(port_mmio + EDMA_HALTCOND);
949 pp->cached.unknown_rsvd = readl(port_mmio + EDMA_UNKNOWN_RSVD);
Mark Lord08da1752009-02-25 15:13:03 -0500950}
951
952/**
953 * mv_write_cached_reg - write to a cached port register
954 * @addr: hardware address of the register
955 * @old: pointer to cached value of the register
956 * @new: new value for the register
957 *
958 * Write a new value to a cached register,
959 * but only if the value is different from before.
960 */
961static inline void mv_write_cached_reg(void __iomem *addr, u32 *old, u32 new)
962{
963 if (new != *old) {
Mark Lord12f3b6d2009-04-06 15:26:24 -0400964 unsigned long laddr;
Mark Lord08da1752009-02-25 15:13:03 -0500965 *old = new;
Mark Lord12f3b6d2009-04-06 15:26:24 -0400966 /*
967 * Workaround for 88SX60x1-B2 FEr SATA#13:
968 * Read-after-write is needed to prevent generating 64-bit
969 * write cycles on the PCI bus for SATA interface registers
970 * at offsets ending in 0x4 or 0xc.
971 *
972 * Looks like a lot of fuss, but it avoids an unnecessary
973 * +1 usec read-after-write delay for unaffected registers.
974 */
975 laddr = (long)addr & 0xffff;
976 if (laddr >= 0x300 && laddr <= 0x33c) {
977 laddr &= 0x000f;
978 if (laddr == 0x4 || laddr == 0xc) {
979 writelfl(new, addr); /* read after write */
980 return;
981 }
982 }
983 writel(new, addr); /* unaffected by the errata */
Mark Lord08da1752009-02-25 15:13:03 -0500984 }
985}
986
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400987static void mv_set_edma_ptrs(void __iomem *port_mmio,
988 struct mv_host_priv *hpriv,
989 struct mv_port_priv *pp)
990{
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400991 u32 index;
992
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400993 /*
994 * initialize request queue
995 */
Mark Lordfcfb1f72008-04-19 15:06:40 -0400996 pp->req_idx &= MV_MAX_Q_DEPTH_MASK; /* paranoia */
997 index = pp->req_idx << EDMA_REQ_Q_PTR_SHIFT;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -0400998
Jeff Garzikc5d3e452007-07-11 18:30:50 -0400999 WARN_ON(pp->crqb_dma & 0x3ff);
Mark Lordcae5a292009-04-06 16:43:45 -04001000 writel((pp->crqb_dma >> 16) >> 16, port_mmio + EDMA_REQ_Q_BASE_HI);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04001001 writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | index,
Mark Lordcae5a292009-04-06 16:43:45 -04001002 port_mmio + EDMA_REQ_Q_IN_PTR);
1003 writelfl(index, port_mmio + EDMA_REQ_Q_OUT_PTR);
Jeff Garzikc5d3e452007-07-11 18:30:50 -04001004
1005 /*
1006 * initialize response queue
1007 */
Mark Lordfcfb1f72008-04-19 15:06:40 -04001008 pp->resp_idx &= MV_MAX_Q_DEPTH_MASK; /* paranoia */
1009 index = pp->resp_idx << EDMA_RSP_Q_PTR_SHIFT;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04001010
Jeff Garzikc5d3e452007-07-11 18:30:50 -04001011 WARN_ON(pp->crpb_dma & 0xff);
Mark Lordcae5a292009-04-06 16:43:45 -04001012 writel((pp->crpb_dma >> 16) >> 16, port_mmio + EDMA_RSP_Q_BASE_HI);
1013 writelfl(index, port_mmio + EDMA_RSP_Q_IN_PTR);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04001014 writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) | index,
Mark Lordcae5a292009-04-06 16:43:45 -04001015 port_mmio + EDMA_RSP_Q_OUT_PTR);
Jeff Garzikc5d3e452007-07-11 18:30:50 -04001016}
1017
Mark Lord2b748a02009-03-10 22:01:17 -04001018static void mv_write_main_irq_mask(u32 mask, struct mv_host_priv *hpriv)
1019{
1020 /*
1021 * When writing to the main_irq_mask in hardware,
1022 * we must ensure exclusivity between the interrupt coalescing bits
1023 * and the corresponding individual port DONE_IRQ bits.
1024 *
1025 * Note that this register is really an "IRQ enable" register,
1026 * not an "IRQ mask" register as Marvell's naming might suggest.
1027 */
1028 if (mask & (ALL_PORTS_COAL_DONE | PORTS_0_3_COAL_DONE))
1029 mask &= ~DONE_IRQ_0_3;
1030 if (mask & (ALL_PORTS_COAL_DONE | PORTS_4_7_COAL_DONE))
1031 mask &= ~DONE_IRQ_4_7;
1032 writelfl(mask, hpriv->main_irq_mask_addr);
1033}
1034
Mark Lordc4de5732008-05-17 13:35:21 -04001035static void mv_set_main_irq_mask(struct ata_host *host,
1036 u32 disable_bits, u32 enable_bits)
1037{
1038 struct mv_host_priv *hpriv = host->private_data;
1039 u32 old_mask, new_mask;
1040
Mark Lord96e2c4872008-05-17 13:38:00 -04001041 old_mask = hpriv->main_irq_mask;
Mark Lordc4de5732008-05-17 13:35:21 -04001042 new_mask = (old_mask & ~disable_bits) | enable_bits;
Mark Lord96e2c4872008-05-17 13:38:00 -04001043 if (new_mask != old_mask) {
1044 hpriv->main_irq_mask = new_mask;
Mark Lord2b748a02009-03-10 22:01:17 -04001045 mv_write_main_irq_mask(new_mask, hpriv);
Mark Lord96e2c4872008-05-17 13:38:00 -04001046 }
Mark Lordc4de5732008-05-17 13:35:21 -04001047}
1048
1049static void mv_enable_port_irqs(struct ata_port *ap,
1050 unsigned int port_bits)
1051{
1052 unsigned int shift, hardport, port = ap->port_no;
1053 u32 disable_bits, enable_bits;
1054
1055 MV_PORT_TO_SHIFT_AND_HARDPORT(port, shift, hardport);
1056
1057 disable_bits = (DONE_IRQ | ERR_IRQ) << shift;
1058 enable_bits = port_bits << shift;
1059 mv_set_main_irq_mask(ap->host, disable_bits, enable_bits);
1060}
1061
Mark Lord00b81232009-01-30 18:47:51 -05001062static void mv_clear_and_enable_port_irqs(struct ata_port *ap,
1063 void __iomem *port_mmio,
1064 unsigned int port_irqs)
1065{
1066 struct mv_host_priv *hpriv = ap->host->private_data;
1067 int hardport = mv_hardport_from_port(ap->port_no);
1068 void __iomem *hc_mmio = mv_hc_base_from_port(
1069 mv_host_base(ap->host), ap->port_no);
1070 u32 hc_irq_cause;
1071
1072 /* clear EDMA event indicators, if any */
Mark Lordcae5a292009-04-06 16:43:45 -04001073 writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE);
Mark Lord00b81232009-01-30 18:47:51 -05001074
1075 /* clear pending irq events */
1076 hc_irq_cause = ~((DEV_IRQ | DMA_IRQ) << hardport);
Mark Lordcae5a292009-04-06 16:43:45 -04001077 writelfl(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE);
Mark Lord00b81232009-01-30 18:47:51 -05001078
1079 /* clear FIS IRQ Cause */
1080 if (IS_GEN_IIE(hpriv))
Mark Lordcae5a292009-04-06 16:43:45 -04001081 writelfl(0, port_mmio + FIS_IRQ_CAUSE);
Mark Lord00b81232009-01-30 18:47:51 -05001082
1083 mv_enable_port_irqs(ap, port_irqs);
1084}
1085
Mark Lord2b748a02009-03-10 22:01:17 -04001086static void mv_set_irq_coalescing(struct ata_host *host,
1087 unsigned int count, unsigned int usecs)
1088{
1089 struct mv_host_priv *hpriv = host->private_data;
1090 void __iomem *mmio = hpriv->base, *hc_mmio;
1091 u32 coal_enable = 0;
1092 unsigned long flags;
Mark Lord6abf4672009-03-11 00:56:00 -04001093 unsigned int clks, is_dual_hc = hpriv->n_ports > MV_PORTS_PER_HC;
Mark Lord2b748a02009-03-10 22:01:17 -04001094 const u32 coal_disable = PORTS_0_3_COAL_DONE | PORTS_4_7_COAL_DONE |
1095 ALL_PORTS_COAL_DONE;
1096
1097 /* Disable IRQ coalescing if either threshold is zero */
1098 if (!usecs || !count) {
1099 clks = count = 0;
1100 } else {
1101 /* Respect maximum limits of the hardware */
1102 clks = usecs * COAL_CLOCKS_PER_USEC;
1103 if (clks > MAX_COAL_TIME_THRESHOLD)
1104 clks = MAX_COAL_TIME_THRESHOLD;
1105 if (count > MAX_COAL_IO_COUNT)
1106 count = MAX_COAL_IO_COUNT;
1107 }
1108
1109 spin_lock_irqsave(&host->lock, flags);
Mark Lord6abf4672009-03-11 00:56:00 -04001110 mv_set_main_irq_mask(host, coal_disable, 0);
Mark Lord2b748a02009-03-10 22:01:17 -04001111
Mark Lord6abf4672009-03-11 00:56:00 -04001112 if (is_dual_hc && !IS_GEN_I(hpriv)) {
Mark Lord2b748a02009-03-10 22:01:17 -04001113 /*
Mark Lord6abf4672009-03-11 00:56:00 -04001114 * GEN_II/GEN_IIE with dual host controllers:
1115 * one set of global thresholds for the entire chip.
Mark Lord2b748a02009-03-10 22:01:17 -04001116 */
Mark Lordcae5a292009-04-06 16:43:45 -04001117 writel(clks, mmio + IRQ_COAL_TIME_THRESHOLD);
1118 writel(count, mmio + IRQ_COAL_IO_THRESHOLD);
Mark Lord2b748a02009-03-10 22:01:17 -04001119 /* clear leftover coal IRQ bit */
Mark Lordcae5a292009-04-06 16:43:45 -04001120 writel(~ALL_PORTS_COAL_IRQ, mmio + IRQ_COAL_CAUSE);
Mark Lord6abf4672009-03-11 00:56:00 -04001121 if (count)
1122 coal_enable = ALL_PORTS_COAL_DONE;
1123 clks = count = 0; /* force clearing of regular regs below */
Mark Lord2b748a02009-03-10 22:01:17 -04001124 }
Mark Lord6abf4672009-03-11 00:56:00 -04001125
Mark Lord2b748a02009-03-10 22:01:17 -04001126 /*
1127 * All chips: independent thresholds for each HC on the chip.
1128 */
1129 hc_mmio = mv_hc_base_from_port(mmio, 0);
Mark Lordcae5a292009-04-06 16:43:45 -04001130 writel(clks, hc_mmio + HC_IRQ_COAL_TIME_THRESHOLD);
1131 writel(count, hc_mmio + HC_IRQ_COAL_IO_THRESHOLD);
1132 writel(~HC_COAL_IRQ, hc_mmio + HC_IRQ_CAUSE);
Mark Lord6abf4672009-03-11 00:56:00 -04001133 if (count)
1134 coal_enable |= PORTS_0_3_COAL_DONE;
1135 if (is_dual_hc) {
Mark Lord2b748a02009-03-10 22:01:17 -04001136 hc_mmio = mv_hc_base_from_port(mmio, MV_PORTS_PER_HC);
Mark Lordcae5a292009-04-06 16:43:45 -04001137 writel(clks, hc_mmio + HC_IRQ_COAL_TIME_THRESHOLD);
1138 writel(count, hc_mmio + HC_IRQ_COAL_IO_THRESHOLD);
1139 writel(~HC_COAL_IRQ, hc_mmio + HC_IRQ_CAUSE);
Mark Lord6abf4672009-03-11 00:56:00 -04001140 if (count)
1141 coal_enable |= PORTS_4_7_COAL_DONE;
Mark Lord2b748a02009-03-10 22:01:17 -04001142 }
Mark Lord2b748a02009-03-10 22:01:17 -04001143
Mark Lord6abf4672009-03-11 00:56:00 -04001144 mv_set_main_irq_mask(host, 0, coal_enable);
Mark Lord2b748a02009-03-10 22:01:17 -04001145 spin_unlock_irqrestore(&host->lock, flags);
1146}
1147
Brett Russ05b308e2005-10-05 17:08:53 -04001148/**
Mark Lord00b81232009-01-30 18:47:51 -05001149 * mv_start_edma - Enable eDMA engine
Brett Russ05b308e2005-10-05 17:08:53 -04001150 * @base: port base address
1151 * @pp: port private data
1152 *
Tejun Heobeec7db2006-02-11 19:11:13 +09001153 * Verify the local cache of the eDMA state is accurate with a
1154 * WARN_ON.
Brett Russ05b308e2005-10-05 17:08:53 -04001155 *
1156 * LOCKING:
1157 * Inherited from caller.
1158 */
Mark Lord00b81232009-01-30 18:47:51 -05001159static void mv_start_edma(struct ata_port *ap, void __iomem *port_mmio,
Mark Lord72109162008-01-26 18:31:33 -05001160 struct mv_port_priv *pp, u8 protocol)
Brett Russ31961942005-09-30 01:36:00 -04001161{
Mark Lord72109162008-01-26 18:31:33 -05001162 int want_ncq = (protocol == ATA_PROT_NCQ);
1163
1164 if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
1165 int using_ncq = ((pp->pp_flags & MV_PP_FLAG_NCQ_EN) != 0);
1166 if (want_ncq != using_ncq)
Mark Lordb5624682008-03-31 19:34:40 -04001167 mv_stop_edma(ap);
Mark Lord72109162008-01-26 18:31:33 -05001168 }
Jeff Garzikc5d3e452007-07-11 18:30:50 -04001169 if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN)) {
Mark Lord0c589122008-01-26 18:31:16 -05001170 struct mv_host_priv *hpriv = ap->host->private_data;
Mark Lord0c589122008-01-26 18:31:16 -05001171
Mark Lord00b81232009-01-30 18:47:51 -05001172 mv_edma_cfg(ap, want_ncq, 1);
Mark Lord0c589122008-01-26 18:31:16 -05001173
Mark Lordf630d562008-01-26 18:31:00 -05001174 mv_set_edma_ptrs(port_mmio, hpriv, pp);
Mark Lord00b81232009-01-30 18:47:51 -05001175 mv_clear_and_enable_port_irqs(ap, port_mmio, DONE_IRQ|ERR_IRQ);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04001176
Mark Lordcae5a292009-04-06 16:43:45 -04001177 writelfl(EDMA_EN, port_mmio + EDMA_CMD);
Brett Russafb0edd2005-10-05 17:08:42 -04001178 pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
1179 }
Brett Russ31961942005-09-30 01:36:00 -04001180}
1181
Mark Lord9b2c4e02008-05-02 02:09:14 -04001182static void mv_wait_for_edma_empty_idle(struct ata_port *ap)
1183{
1184 void __iomem *port_mmio = mv_ap_base(ap);
1185 const u32 empty_idle = (EDMA_STATUS_CACHE_EMPTY | EDMA_STATUS_IDLE);
1186 const int per_loop = 5, timeout = (15 * 1000 / per_loop);
1187 int i;
1188
1189 /*
1190 * Wait for the EDMA engine to finish transactions in progress.
Mark Lordc46938c2008-05-02 14:02:28 -04001191 * No idea what a good "timeout" value might be, but measurements
1192 * indicate that it often requires hundreds of microseconds
1193 * with two drives in-use. So we use the 15msec value above
1194 * as a rough guess at what even more drives might require.
Mark Lord9b2c4e02008-05-02 02:09:14 -04001195 */
1196 for (i = 0; i < timeout; ++i) {
Mark Lordcae5a292009-04-06 16:43:45 -04001197 u32 edma_stat = readl(port_mmio + EDMA_STATUS);
Mark Lord9b2c4e02008-05-02 02:09:14 -04001198 if ((edma_stat & empty_idle) == empty_idle)
1199 break;
1200 udelay(per_loop);
1201 }
Joe Perchesa9a79df2011-04-15 15:51:59 -07001202 /* ata_port_info(ap, "%s: %u+ usecs\n", __func__, i); */
Mark Lord9b2c4e02008-05-02 02:09:14 -04001203}
1204
Brett Russ05b308e2005-10-05 17:08:53 -04001205/**
Mark Lorde12bef52008-03-31 19:33:56 -04001206 * mv_stop_edma_engine - Disable eDMA engine
Mark Lordb5624682008-03-31 19:34:40 -04001207 * @port_mmio: io base address
Brett Russ05b308e2005-10-05 17:08:53 -04001208 *
1209 * LOCKING:
1210 * Inherited from caller.
1211 */
Mark Lordb5624682008-03-31 19:34:40 -04001212static int mv_stop_edma_engine(void __iomem *port_mmio)
Brett Russ31961942005-09-30 01:36:00 -04001213{
Mark Lordb5624682008-03-31 19:34:40 -04001214 int i;
Brett Russ31961942005-09-30 01:36:00 -04001215
Mark Lordb5624682008-03-31 19:34:40 -04001216 /* Disable eDMA. The disable bit auto clears. */
Mark Lordcae5a292009-04-06 16:43:45 -04001217 writelfl(EDMA_DS, port_mmio + EDMA_CMD);
Jeff Garzik8b260242005-11-12 12:32:50 -05001218
Mark Lordb5624682008-03-31 19:34:40 -04001219 /* Wait for the chip to confirm eDMA is off. */
1220 for (i = 10000; i > 0; i--) {
Mark Lordcae5a292009-04-06 16:43:45 -04001221 u32 reg = readl(port_mmio + EDMA_CMD);
Jeff Garzik4537deb2007-07-12 14:30:19 -04001222 if (!(reg & EDMA_EN))
Mark Lordb5624682008-03-31 19:34:40 -04001223 return 0;
1224 udelay(10);
Brett Russ31961942005-09-30 01:36:00 -04001225 }
Mark Lordb5624682008-03-31 19:34:40 -04001226 return -EIO;
Brett Russ31961942005-09-30 01:36:00 -04001227}
1228
Mark Lorde12bef52008-03-31 19:33:56 -04001229static int mv_stop_edma(struct ata_port *ap)
Jeff Garzik0ea9e172007-07-13 17:06:45 -04001230{
Mark Lordb5624682008-03-31 19:34:40 -04001231 void __iomem *port_mmio = mv_ap_base(ap);
1232 struct mv_port_priv *pp = ap->private_data;
Mark Lord66e57a22009-01-30 18:52:58 -05001233 int err = 0;
Jeff Garzik0ea9e172007-07-13 17:06:45 -04001234
Mark Lordb5624682008-03-31 19:34:40 -04001235 if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN))
1236 return 0;
1237 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
Mark Lord9b2c4e02008-05-02 02:09:14 -04001238 mv_wait_for_edma_empty_idle(ap);
Mark Lordb5624682008-03-31 19:34:40 -04001239 if (mv_stop_edma_engine(port_mmio)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001240 ata_port_err(ap, "Unable to stop eDMA\n");
Mark Lord66e57a22009-01-30 18:52:58 -05001241 err = -EIO;
Mark Lordb5624682008-03-31 19:34:40 -04001242 }
Mark Lord66e57a22009-01-30 18:52:58 -05001243 mv_edma_cfg(ap, 0, 0);
1244 return err;
Jeff Garzik0ea9e172007-07-13 17:06:45 -04001245}
1246
Jeff Garzik8a70f8d2005-10-05 17:19:47 -04001247#ifdef ATA_DEBUG
Brett Russ31961942005-09-30 01:36:00 -04001248static void mv_dump_mem(void __iomem *start, unsigned bytes)
1249{
Brett Russ31961942005-09-30 01:36:00 -04001250 int b, w;
1251 for (b = 0; b < bytes; ) {
1252 DPRINTK("%p: ", start + b);
1253 for (w = 0; b < bytes && w < 4; w++) {
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001254 printk("%08x ", readl(start + b));
Brett Russ31961942005-09-30 01:36:00 -04001255 b += sizeof(u32);
1256 }
1257 printk("\n");
1258 }
Brett Russ31961942005-09-30 01:36:00 -04001259}
Jeff Garzik8a70f8d2005-10-05 17:19:47 -04001260#endif
Andrew Lunn13b74082012-09-28 17:04:10 +02001261#if defined(ATA_DEBUG) || defined(CONFIG_PCI)
Brett Russ31961942005-09-30 01:36:00 -04001262static void mv_dump_pci_cfg(struct pci_dev *pdev, unsigned bytes)
1263{
1264#ifdef ATA_DEBUG
1265 int b, w;
1266 u32 dw;
1267 for (b = 0; b < bytes; ) {
1268 DPRINTK("%02x: ", b);
1269 for (w = 0; b < bytes && w < 4; w++) {
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001270 (void) pci_read_config_dword(pdev, b, &dw);
1271 printk("%08x ", dw);
Brett Russ31961942005-09-30 01:36:00 -04001272 b += sizeof(u32);
1273 }
1274 printk("\n");
1275 }
1276#endif
1277}
Andrew Lunn13b74082012-09-28 17:04:10 +02001278#endif
Brett Russ31961942005-09-30 01:36:00 -04001279static void mv_dump_all_regs(void __iomem *mmio_base, int port,
1280 struct pci_dev *pdev)
1281{
1282#ifdef ATA_DEBUG
Jeff Garzik8b260242005-11-12 12:32:50 -05001283 void __iomem *hc_base = mv_hc_base(mmio_base,
Brett Russ31961942005-09-30 01:36:00 -04001284 port >> MV_PORT_HC_SHIFT);
1285 void __iomem *port_base;
1286 int start_port, num_ports, p, start_hc, num_hcs, hc;
1287
1288 if (0 > port) {
1289 start_hc = start_port = 0;
1290 num_ports = 8; /* shld be benign for 4 port devs */
1291 num_hcs = 2;
1292 } else {
1293 start_hc = port >> MV_PORT_HC_SHIFT;
1294 start_port = port;
1295 num_ports = num_hcs = 1;
1296 }
Jeff Garzik8b260242005-11-12 12:32:50 -05001297 DPRINTK("All registers for port(s) %u-%u:\n", start_port,
Brett Russ31961942005-09-30 01:36:00 -04001298 num_ports > 1 ? num_ports - 1 : start_port);
1299
1300 if (NULL != pdev) {
1301 DPRINTK("PCI config space regs:\n");
1302 mv_dump_pci_cfg(pdev, 0x68);
1303 }
1304 DPRINTK("PCI regs:\n");
1305 mv_dump_mem(mmio_base+0xc00, 0x3c);
1306 mv_dump_mem(mmio_base+0xd00, 0x34);
1307 mv_dump_mem(mmio_base+0xf00, 0x4);
1308 mv_dump_mem(mmio_base+0x1d00, 0x6c);
1309 for (hc = start_hc; hc < start_hc + num_hcs; hc++) {
Dan Alonid220c372006-04-10 23:20:22 -07001310 hc_base = mv_hc_base(mmio_base, hc);
Brett Russ31961942005-09-30 01:36:00 -04001311 DPRINTK("HC regs (HC %i):\n", hc);
1312 mv_dump_mem(hc_base, 0x1c);
1313 }
1314 for (p = start_port; p < start_port + num_ports; p++) {
1315 port_base = mv_port_base(mmio_base, p);
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001316 DPRINTK("EDMA regs (port %i):\n", p);
Brett Russ31961942005-09-30 01:36:00 -04001317 mv_dump_mem(port_base, 0x54);
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001318 DPRINTK("SATA regs (port %i):\n", p);
Brett Russ31961942005-09-30 01:36:00 -04001319 mv_dump_mem(port_base+0x300, 0x60);
1320 }
1321#endif
1322}
1323
Brett Russ20f733e2005-09-01 18:26:17 -04001324static unsigned int mv_scr_offset(unsigned int sc_reg_in)
1325{
1326 unsigned int ofs;
1327
1328 switch (sc_reg_in) {
1329 case SCR_STATUS:
1330 case SCR_CONTROL:
1331 case SCR_ERROR:
Mark Lordcae5a292009-04-06 16:43:45 -04001332 ofs = SATA_STATUS + (sc_reg_in * sizeof(u32));
Brett Russ20f733e2005-09-01 18:26:17 -04001333 break;
1334 case SCR_ACTIVE:
Mark Lordcae5a292009-04-06 16:43:45 -04001335 ofs = SATA_ACTIVE; /* active is not with the others */
Brett Russ20f733e2005-09-01 18:26:17 -04001336 break;
1337 default:
1338 ofs = 0xffffffffU;
1339 break;
1340 }
1341 return ofs;
1342}
1343
Tejun Heo82ef04f2008-07-31 17:02:40 +09001344static int mv_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val)
Brett Russ20f733e2005-09-01 18:26:17 -04001345{
1346 unsigned int ofs = mv_scr_offset(sc_reg_in);
1347
Tejun Heoda3dbb12007-07-16 14:29:40 +09001348 if (ofs != 0xffffffffU) {
Tejun Heo82ef04f2008-07-31 17:02:40 +09001349 *val = readl(mv_ap_base(link->ap) + ofs);
Tejun Heoda3dbb12007-07-16 14:29:40 +09001350 return 0;
1351 } else
1352 return -EINVAL;
Brett Russ20f733e2005-09-01 18:26:17 -04001353}
1354
Tejun Heo82ef04f2008-07-31 17:02:40 +09001355static int mv_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val)
Brett Russ20f733e2005-09-01 18:26:17 -04001356{
1357 unsigned int ofs = mv_scr_offset(sc_reg_in);
1358
Tejun Heoda3dbb12007-07-16 14:29:40 +09001359 if (ofs != 0xffffffffU) {
Mark Lord20091772009-04-06 15:24:57 -04001360 void __iomem *addr = mv_ap_base(link->ap) + ofs;
1361 if (sc_reg_in == SCR_CONTROL) {
1362 /*
1363 * Workaround for 88SX60x1 FEr SATA#26:
1364 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001365 * COMRESETs have to take care not to accidentally
Mark Lord20091772009-04-06 15:24:57 -04001366 * put the drive to sleep when writing SCR_CONTROL.
1367 * Setting bits 12..15 prevents this problem.
1368 *
1369 * So if we see an outbound COMMRESET, set those bits.
1370 * Ditto for the followup write that clears the reset.
1371 *
1372 * The proprietary driver does this for
1373 * all chip versions, and so do we.
1374 */
1375 if ((val & 0xf) == 1 || (readl(addr) & 0xf) == 1)
1376 val |= 0xf000;
1377 }
1378 writelfl(val, addr);
Tejun Heoda3dbb12007-07-16 14:29:40 +09001379 return 0;
1380 } else
1381 return -EINVAL;
Brett Russ20f733e2005-09-01 18:26:17 -04001382}
1383
Mark Lordf2738272008-01-26 18:32:29 -05001384static void mv6_dev_config(struct ata_device *adev)
1385{
1386 /*
Mark Lorde49856d2008-04-16 14:59:07 -04001387 * Deal with Gen-II ("mv6") hardware quirks/restrictions:
1388 *
1389 * Gen-II does not support NCQ over a port multiplier
1390 * (no FIS-based switching).
Mark Lordf2738272008-01-26 18:32:29 -05001391 */
Mark Lorde49856d2008-04-16 14:59:07 -04001392 if (adev->flags & ATA_DFLAG_NCQ) {
Mark Lord352fab72008-04-19 14:43:42 -04001393 if (sata_pmp_attached(adev->link->ap)) {
Mark Lorde49856d2008-04-16 14:59:07 -04001394 adev->flags &= ~ATA_DFLAG_NCQ;
Joe Perchesa9a79df2011-04-15 15:51:59 -07001395 ata_dev_info(adev,
Mark Lord352fab72008-04-19 14:43:42 -04001396 "NCQ disabled for command-based switching\n");
Mark Lord352fab72008-04-19 14:43:42 -04001397 }
Mark Lorde49856d2008-04-16 14:59:07 -04001398 }
Mark Lordf2738272008-01-26 18:32:29 -05001399}
1400
Mark Lord3e4a1392008-05-02 02:10:02 -04001401static int mv_qc_defer(struct ata_queued_cmd *qc)
1402{
1403 struct ata_link *link = qc->dev->link;
1404 struct ata_port *ap = link->ap;
1405 struct mv_port_priv *pp = ap->private_data;
1406
1407 /*
Mark Lord29d187b2008-05-02 02:15:37 -04001408 * Don't allow new commands if we're in a delayed EH state
1409 * for NCQ and/or FIS-based switching.
1410 */
1411 if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH)
1412 return ATA_DEFER_PORT;
Gwendal Grignou159a7ff2009-10-12 15:44:00 -07001413
1414 /* PIO commands need exclusive link: no other commands [DMA or PIO]
1415 * can run concurrently.
1416 * set excl_link when we want to send a PIO command in DMA mode
1417 * or a non-NCQ command in NCQ mode.
1418 * When we receive a command from that link, and there are no
1419 * outstanding commands, mark a flag to clear excl_link and let
1420 * the command go through.
1421 */
1422 if (unlikely(ap->excl_link)) {
1423 if (link == ap->excl_link) {
1424 if (ap->nr_active_links)
1425 return ATA_DEFER_PORT;
1426 qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
1427 return 0;
1428 } else
1429 return ATA_DEFER_PORT;
1430 }
1431
Mark Lord29d187b2008-05-02 02:15:37 -04001432 /*
Mark Lord3e4a1392008-05-02 02:10:02 -04001433 * If the port is completely idle, then allow the new qc.
1434 */
1435 if (ap->nr_active_links == 0)
1436 return 0;
1437
Tejun Heo4bdee6c2008-08-13 20:24:16 +09001438 /*
1439 * The port is operating in host queuing mode (EDMA) with NCQ
1440 * enabled, allow multiple NCQ commands. EDMA also allows
1441 * queueing multiple DMA commands but libata core currently
1442 * doesn't allow it.
1443 */
1444 if ((pp->pp_flags & MV_PP_FLAG_EDMA_EN) &&
Gwendal Grignou159a7ff2009-10-12 15:44:00 -07001445 (pp->pp_flags & MV_PP_FLAG_NCQ_EN)) {
1446 if (ata_is_ncq(qc->tf.protocol))
1447 return 0;
1448 else {
1449 ap->excl_link = link;
1450 return ATA_DEFER_PORT;
1451 }
1452 }
Tejun Heo4bdee6c2008-08-13 20:24:16 +09001453
Mark Lord3e4a1392008-05-02 02:10:02 -04001454 return ATA_DEFER_PORT;
1455}
1456
Mark Lord08da1752009-02-25 15:13:03 -05001457static void mv_config_fbs(struct ata_port *ap, int want_ncq, int want_fbs)
Mark Lorde49856d2008-04-16 14:59:07 -04001458{
Mark Lord08da1752009-02-25 15:13:03 -05001459 struct mv_port_priv *pp = ap->private_data;
1460 void __iomem *port_mmio;
Mark Lord00f42ea2008-05-02 02:11:45 -04001461
Mark Lord08da1752009-02-25 15:13:03 -05001462 u32 fiscfg, *old_fiscfg = &pp->cached.fiscfg;
1463 u32 ltmode, *old_ltmode = &pp->cached.ltmode;
1464 u32 haltcond, *old_haltcond = &pp->cached.haltcond;
Mark Lord00f42ea2008-05-02 02:11:45 -04001465
Mark Lord08da1752009-02-25 15:13:03 -05001466 ltmode = *old_ltmode & ~LTMODE_BIT8;
1467 haltcond = *old_haltcond | EDMA_ERR_DEV;
Mark Lord00f42ea2008-05-02 02:11:45 -04001468
1469 if (want_fbs) {
Mark Lord08da1752009-02-25 15:13:03 -05001470 fiscfg = *old_fiscfg | FISCFG_SINGLE_SYNC;
1471 ltmode = *old_ltmode | LTMODE_BIT8;
Mark Lord4c299ca2008-05-02 02:16:20 -04001472 if (want_ncq)
Mark Lord08da1752009-02-25 15:13:03 -05001473 haltcond &= ~EDMA_ERR_DEV;
Mark Lord4c299ca2008-05-02 02:16:20 -04001474 else
Mark Lord08da1752009-02-25 15:13:03 -05001475 fiscfg |= FISCFG_WAIT_DEV_ERR;
1476 } else {
1477 fiscfg = *old_fiscfg & ~(FISCFG_SINGLE_SYNC | FISCFG_WAIT_DEV_ERR);
Mark Lorde49856d2008-04-16 14:59:07 -04001478 }
Mark Lord00f42ea2008-05-02 02:11:45 -04001479
Mark Lord08da1752009-02-25 15:13:03 -05001480 port_mmio = mv_ap_base(ap);
Mark Lordcae5a292009-04-06 16:43:45 -04001481 mv_write_cached_reg(port_mmio + FISCFG, old_fiscfg, fiscfg);
1482 mv_write_cached_reg(port_mmio + LTMODE, old_ltmode, ltmode);
1483 mv_write_cached_reg(port_mmio + EDMA_HALTCOND, old_haltcond, haltcond);
Mark Lord0c589122008-01-26 18:31:16 -05001484}
Jeff Garzike4e7b892006-01-31 12:18:41 -05001485
Mark Lorddd2890f2008-05-02 02:10:56 -04001486static void mv_60x1_errata_sata25(struct ata_port *ap, int want_ncq)
1487{
1488 struct mv_host_priv *hpriv = ap->host->private_data;
1489 u32 old, new;
1490
1491 /* workaround for 88SX60x1 FEr SATA#25 (part 1) */
Mark Lordcae5a292009-04-06 16:43:45 -04001492 old = readl(hpriv->base + GPIO_PORT_CTL);
Mark Lorddd2890f2008-05-02 02:10:56 -04001493 if (want_ncq)
1494 new = old | (1 << 22);
1495 else
1496 new = old & ~(1 << 22);
1497 if (new != old)
Mark Lordcae5a292009-04-06 16:43:45 -04001498 writel(new, hpriv->base + GPIO_PORT_CTL);
Mark Lorddd2890f2008-05-02 02:10:56 -04001499}
1500
Mark Lordc01e8a22009-02-25 15:14:48 -05001501/**
Mark Lord40f21b12009-03-10 18:51:04 -04001502 * mv_bmdma_enable - set a magic bit on GEN_IIE to allow bmdma
1503 * @ap: Port being initialized
Mark Lordc01e8a22009-02-25 15:14:48 -05001504 *
1505 * There are two DMA modes on these chips: basic DMA, and EDMA.
1506 *
1507 * Bit-0 of the "EDMA RESERVED" register enables/disables use
1508 * of basic DMA on the GEN_IIE versions of the chips.
1509 *
1510 * This bit survives EDMA resets, and must be set for basic DMA
1511 * to function, and should be cleared when EDMA is active.
1512 */
1513static void mv_bmdma_enable_iie(struct ata_port *ap, int enable_bmdma)
1514{
1515 struct mv_port_priv *pp = ap->private_data;
1516 u32 new, *old = &pp->cached.unknown_rsvd;
1517
1518 if (enable_bmdma)
1519 new = *old | 1;
1520 else
1521 new = *old & ~1;
Mark Lordcae5a292009-04-06 16:43:45 -04001522 mv_write_cached_reg(mv_ap_base(ap) + EDMA_UNKNOWN_RSVD, old, new);
Mark Lordc01e8a22009-02-25 15:14:48 -05001523}
1524
Mark Lord000b3442009-03-15 11:33:19 -04001525/*
1526 * SOC chips have an issue whereby the HDD LEDs don't always blink
1527 * during I/O when NCQ is enabled. Enabling a special "LED blink" mode
1528 * of the SOC takes care of it, generating a steady blink rate when
1529 * any drive on the chip is active.
1530 *
1531 * Unfortunately, the blink mode is a global hardware setting for the SOC,
1532 * so we must use it whenever at least one port on the SOC has NCQ enabled.
1533 *
1534 * We turn "LED blink" off when NCQ is not in use anywhere, because the normal
1535 * LED operation works then, and provides better (more accurate) feedback.
1536 *
1537 * Note that this code assumes that an SOC never has more than one HC onboard.
1538 */
1539static void mv_soc_led_blink_enable(struct ata_port *ap)
1540{
1541 struct ata_host *host = ap->host;
1542 struct mv_host_priv *hpriv = host->private_data;
1543 void __iomem *hc_mmio;
1544 u32 led_ctrl;
1545
1546 if (hpriv->hp_flags & MV_HP_QUIRK_LED_BLINK_EN)
1547 return;
1548 hpriv->hp_flags |= MV_HP_QUIRK_LED_BLINK_EN;
1549 hc_mmio = mv_hc_base_from_port(mv_host_base(host), ap->port_no);
Mark Lordcae5a292009-04-06 16:43:45 -04001550 led_ctrl = readl(hc_mmio + SOC_LED_CTRL);
1551 writel(led_ctrl | SOC_LED_CTRL_BLINK, hc_mmio + SOC_LED_CTRL);
Mark Lord000b3442009-03-15 11:33:19 -04001552}
1553
1554static void mv_soc_led_blink_disable(struct ata_port *ap)
1555{
1556 struct ata_host *host = ap->host;
1557 struct mv_host_priv *hpriv = host->private_data;
1558 void __iomem *hc_mmio;
1559 u32 led_ctrl;
1560 unsigned int port;
1561
1562 if (!(hpriv->hp_flags & MV_HP_QUIRK_LED_BLINK_EN))
1563 return;
1564
1565 /* disable led-blink only if no ports are using NCQ */
1566 for (port = 0; port < hpriv->n_ports; port++) {
1567 struct ata_port *this_ap = host->ports[port];
1568 struct mv_port_priv *pp = this_ap->private_data;
1569
1570 if (pp->pp_flags & MV_PP_FLAG_NCQ_EN)
1571 return;
1572 }
1573
1574 hpriv->hp_flags &= ~MV_HP_QUIRK_LED_BLINK_EN;
1575 hc_mmio = mv_hc_base_from_port(mv_host_base(host), ap->port_no);
Mark Lordcae5a292009-04-06 16:43:45 -04001576 led_ctrl = readl(hc_mmio + SOC_LED_CTRL);
1577 writel(led_ctrl & ~SOC_LED_CTRL_BLINK, hc_mmio + SOC_LED_CTRL);
Mark Lord000b3442009-03-15 11:33:19 -04001578}
1579
Mark Lord00b81232009-01-30 18:47:51 -05001580static void mv_edma_cfg(struct ata_port *ap, int want_ncq, int want_edma)
Jeff Garzike4e7b892006-01-31 12:18:41 -05001581{
1582 u32 cfg;
Mark Lorde12bef52008-03-31 19:33:56 -04001583 struct mv_port_priv *pp = ap->private_data;
1584 struct mv_host_priv *hpriv = ap->host->private_data;
1585 void __iomem *port_mmio = mv_ap_base(ap);
Jeff Garzike4e7b892006-01-31 12:18:41 -05001586
1587 /* set up non-NCQ EDMA configuration */
1588 cfg = EDMA_CFG_Q_DEPTH; /* always 0x1f for *all* chips */
Mark Lordd16ab3f2009-02-25 15:17:43 -05001589 pp->pp_flags &=
1590 ~(MV_PP_FLAG_FBS_EN | MV_PP_FLAG_NCQ_EN | MV_PP_FLAG_FAKE_ATA_BUSY);
Jeff Garzike4e7b892006-01-31 12:18:41 -05001591
1592 if (IS_GEN_I(hpriv))
1593 cfg |= (1 << 8); /* enab config burst size mask */
1594
Mark Lorddd2890f2008-05-02 02:10:56 -04001595 else if (IS_GEN_II(hpriv)) {
Jeff Garzike4e7b892006-01-31 12:18:41 -05001596 cfg |= EDMA_CFG_RD_BRST_EXT | EDMA_CFG_WR_BUFF_LEN;
Mark Lorddd2890f2008-05-02 02:10:56 -04001597 mv_60x1_errata_sata25(ap, want_ncq);
Jeff Garzike4e7b892006-01-31 12:18:41 -05001598
Mark Lorddd2890f2008-05-02 02:10:56 -04001599 } else if (IS_GEN_IIE(hpriv)) {
Mark Lord00f42ea2008-05-02 02:11:45 -04001600 int want_fbs = sata_pmp_attached(ap);
1601 /*
1602 * Possible future enhancement:
1603 *
1604 * The chip can use FBS with non-NCQ, if we allow it,
1605 * But first we need to have the error handling in place
1606 * for this mode (datasheet section 7.3.15.4.2.3).
1607 * So disallow non-NCQ FBS for now.
1608 */
1609 want_fbs &= want_ncq;
1610
Mark Lord08da1752009-02-25 15:13:03 -05001611 mv_config_fbs(ap, want_ncq, want_fbs);
Mark Lord00f42ea2008-05-02 02:11:45 -04001612
1613 if (want_fbs) {
1614 pp->pp_flags |= MV_PP_FLAG_FBS_EN;
1615 cfg |= EDMA_CFG_EDMA_FBS; /* FIS-based switching */
1616 }
1617
Jeff Garzike728eab2007-02-25 02:53:41 -05001618 cfg |= (1 << 23); /* do not mask PM field in rx'd FIS */
Mark Lord00b81232009-01-30 18:47:51 -05001619 if (want_edma) {
1620 cfg |= (1 << 22); /* enab 4-entry host queue cache */
1621 if (!IS_SOC(hpriv))
1622 cfg |= (1 << 18); /* enab early completion */
1623 }
Mark Lord616d4a92008-05-02 02:08:32 -04001624 if (hpriv->hp_flags & MV_HP_CUT_THROUGH)
1625 cfg |= (1 << 17); /* enab cut-thru (dis stor&forwrd) */
Mark Lordc01e8a22009-02-25 15:14:48 -05001626 mv_bmdma_enable_iie(ap, !want_edma);
Mark Lord000b3442009-03-15 11:33:19 -04001627
1628 if (IS_SOC(hpriv)) {
1629 if (want_ncq)
1630 mv_soc_led_blink_enable(ap);
1631 else
1632 mv_soc_led_blink_disable(ap);
1633 }
Jeff Garzike4e7b892006-01-31 12:18:41 -05001634 }
1635
Mark Lord72109162008-01-26 18:31:33 -05001636 if (want_ncq) {
1637 cfg |= EDMA_CFG_NCQ;
1638 pp->pp_flags |= MV_PP_FLAG_NCQ_EN;
Mark Lord00b81232009-01-30 18:47:51 -05001639 }
Mark Lord72109162008-01-26 18:31:33 -05001640
Mark Lordcae5a292009-04-06 16:43:45 -04001641 writelfl(cfg, port_mmio + EDMA_CFG);
Jeff Garzike4e7b892006-01-31 12:18:41 -05001642}
1643
Mark Lordda2fa9b2008-01-26 18:32:45 -05001644static void mv_port_free_dma_mem(struct ata_port *ap)
1645{
1646 struct mv_host_priv *hpriv = ap->host->private_data;
1647 struct mv_port_priv *pp = ap->private_data;
Mark Lordeb73d552008-01-29 13:24:00 -05001648 int tag;
Mark Lordda2fa9b2008-01-26 18:32:45 -05001649
1650 if (pp->crqb) {
1651 dma_pool_free(hpriv->crqb_pool, pp->crqb, pp->crqb_dma);
1652 pp->crqb = NULL;
1653 }
1654 if (pp->crpb) {
1655 dma_pool_free(hpriv->crpb_pool, pp->crpb, pp->crpb_dma);
1656 pp->crpb = NULL;
1657 }
Mark Lordeb73d552008-01-29 13:24:00 -05001658 /*
1659 * For GEN_I, there's no NCQ, so we have only a single sg_tbl.
1660 * For later hardware, we have one unique sg_tbl per NCQ tag.
1661 */
1662 for (tag = 0; tag < MV_MAX_Q_DEPTH; ++tag) {
1663 if (pp->sg_tbl[tag]) {
1664 if (tag == 0 || !IS_GEN_I(hpriv))
1665 dma_pool_free(hpriv->sg_tbl_pool,
1666 pp->sg_tbl[tag],
1667 pp->sg_tbl_dma[tag]);
1668 pp->sg_tbl[tag] = NULL;
1669 }
Mark Lordda2fa9b2008-01-26 18:32:45 -05001670 }
1671}
1672
Brett Russ05b308e2005-10-05 17:08:53 -04001673/**
1674 * mv_port_start - Port specific init/start routine.
1675 * @ap: ATA channel to manipulate
1676 *
1677 * Allocate and point to DMA memory, init port private memory,
1678 * zero indices.
1679 *
1680 * LOCKING:
1681 * Inherited from caller.
1682 */
Brett Russ31961942005-09-30 01:36:00 -04001683static int mv_port_start(struct ata_port *ap)
1684{
Jeff Garzikcca39742006-08-24 03:19:22 -04001685 struct device *dev = ap->host->dev;
1686 struct mv_host_priv *hpriv = ap->host->private_data;
Brett Russ31961942005-09-30 01:36:00 -04001687 struct mv_port_priv *pp;
Mark Lord933cb8e2009-04-06 12:30:43 -04001688 unsigned long flags;
James Bottomleydde20202008-02-19 11:36:56 +01001689 int tag;
Brett Russ31961942005-09-30 01:36:00 -04001690
Tejun Heo24dc5f32007-01-20 16:00:28 +09001691 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
Jeff Garzik6037d6b2005-11-04 22:08:00 -05001692 if (!pp)
Tejun Heo24dc5f32007-01-20 16:00:28 +09001693 return -ENOMEM;
Mark Lordda2fa9b2008-01-26 18:32:45 -05001694 ap->private_data = pp;
Brett Russ31961942005-09-30 01:36:00 -04001695
Mark Lordda2fa9b2008-01-26 18:32:45 -05001696 pp->crqb = dma_pool_alloc(hpriv->crqb_pool, GFP_KERNEL, &pp->crqb_dma);
1697 if (!pp->crqb)
1698 return -ENOMEM;
1699 memset(pp->crqb, 0, MV_CRQB_Q_SZ);
Brett Russ31961942005-09-30 01:36:00 -04001700
Mark Lordda2fa9b2008-01-26 18:32:45 -05001701 pp->crpb = dma_pool_alloc(hpriv->crpb_pool, GFP_KERNEL, &pp->crpb_dma);
1702 if (!pp->crpb)
1703 goto out_port_free_dma_mem;
1704 memset(pp->crpb, 0, MV_CRPB_Q_SZ);
Brett Russ31961942005-09-30 01:36:00 -04001705
Mark Lord3bd0a702008-06-18 12:11:16 -04001706 /* 6041/6081 Rev. "C0" (and newer) are okay with async notify */
1707 if (hpriv->hp_flags & MV_HP_ERRATA_60X1C0)
1708 ap->flags |= ATA_FLAG_AN;
Mark Lordeb73d552008-01-29 13:24:00 -05001709 /*
1710 * For GEN_I, there's no NCQ, so we only allocate a single sg_tbl.
1711 * For later hardware, we need one unique sg_tbl per NCQ tag.
1712 */
1713 for (tag = 0; tag < MV_MAX_Q_DEPTH; ++tag) {
1714 if (tag == 0 || !IS_GEN_I(hpriv)) {
1715 pp->sg_tbl[tag] = dma_pool_alloc(hpriv->sg_tbl_pool,
1716 GFP_KERNEL, &pp->sg_tbl_dma[tag]);
1717 if (!pp->sg_tbl[tag])
1718 goto out_port_free_dma_mem;
1719 } else {
1720 pp->sg_tbl[tag] = pp->sg_tbl[0];
1721 pp->sg_tbl_dma[tag] = pp->sg_tbl_dma[0];
1722 }
1723 }
Mark Lord933cb8e2009-04-06 12:30:43 -04001724
1725 spin_lock_irqsave(ap->lock, flags);
Mark Lord08da1752009-02-25 15:13:03 -05001726 mv_save_cached_regs(ap);
Mark Lord66e57a22009-01-30 18:52:58 -05001727 mv_edma_cfg(ap, 0, 0);
Mark Lord933cb8e2009-04-06 12:30:43 -04001728 spin_unlock_irqrestore(ap->lock, flags);
1729
Brett Russ31961942005-09-30 01:36:00 -04001730 return 0;
Mark Lordda2fa9b2008-01-26 18:32:45 -05001731
1732out_port_free_dma_mem:
1733 mv_port_free_dma_mem(ap);
1734 return -ENOMEM;
Brett Russ31961942005-09-30 01:36:00 -04001735}
1736
Brett Russ05b308e2005-10-05 17:08:53 -04001737/**
1738 * mv_port_stop - Port specific cleanup/stop routine.
1739 * @ap: ATA channel to manipulate
1740 *
1741 * Stop DMA, cleanup port memory.
1742 *
1743 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001744 * This routine uses the host lock to protect the DMA stop.
Brett Russ05b308e2005-10-05 17:08:53 -04001745 */
Brett Russ31961942005-09-30 01:36:00 -04001746static void mv_port_stop(struct ata_port *ap)
1747{
Mark Lord933cb8e2009-04-06 12:30:43 -04001748 unsigned long flags;
1749
1750 spin_lock_irqsave(ap->lock, flags);
Mark Lorde12bef52008-03-31 19:33:56 -04001751 mv_stop_edma(ap);
Mark Lord88e675e2008-05-17 13:36:30 -04001752 mv_enable_port_irqs(ap, 0);
Mark Lord933cb8e2009-04-06 12:30:43 -04001753 spin_unlock_irqrestore(ap->lock, flags);
Mark Lordda2fa9b2008-01-26 18:32:45 -05001754 mv_port_free_dma_mem(ap);
Brett Russ31961942005-09-30 01:36:00 -04001755}
1756
Brett Russ05b308e2005-10-05 17:08:53 -04001757/**
1758 * mv_fill_sg - Fill out the Marvell ePRD (scatter gather) entries
1759 * @qc: queued command whose SG list to source from
1760 *
1761 * Populate the SG list and mark the last entry.
1762 *
1763 * LOCKING:
1764 * Inherited from caller.
1765 */
Jeff Garzik6c087722007-10-12 00:16:23 -04001766static void mv_fill_sg(struct ata_queued_cmd *qc)
Brett Russ31961942005-09-30 01:36:00 -04001767{
1768 struct mv_port_priv *pp = qc->ap->private_data;
Jeff Garzik972c26b2005-10-18 22:14:54 -04001769 struct scatterlist *sg;
Jeff Garzik3be6cbd2007-10-18 16:21:18 -04001770 struct mv_sg *mv_sg, *last_sg = NULL;
Tejun Heoff2aeb12007-12-05 16:43:11 +09001771 unsigned int si;
Brett Russ31961942005-09-30 01:36:00 -04001772
Mark Lordeb73d552008-01-29 13:24:00 -05001773 mv_sg = pp->sg_tbl[qc->tag];
Tejun Heoff2aeb12007-12-05 16:43:11 +09001774 for_each_sg(qc->sg, sg, qc->n_elem, si) {
Jeff Garzikd88184f2007-02-26 01:26:06 -05001775 dma_addr_t addr = sg_dma_address(sg);
1776 u32 sg_len = sg_dma_len(sg);
Brett Russ31961942005-09-30 01:36:00 -04001777
Olof Johansson4007b492007-10-02 20:45:27 -05001778 while (sg_len) {
1779 u32 offset = addr & 0xffff;
1780 u32 len = sg_len;
Brett Russ31961942005-09-30 01:36:00 -04001781
Mark Lord32cd11a2009-02-01 16:50:32 -05001782 if (offset + len > 0x10000)
Olof Johansson4007b492007-10-02 20:45:27 -05001783 len = 0x10000 - offset;
Jeff Garzik972c26b2005-10-18 22:14:54 -04001784
Olof Johansson4007b492007-10-02 20:45:27 -05001785 mv_sg->addr = cpu_to_le32(addr & 0xffffffff);
1786 mv_sg->addr_hi = cpu_to_le32((addr >> 16) >> 16);
Jeff Garzik6c087722007-10-12 00:16:23 -04001787 mv_sg->flags_size = cpu_to_le32(len & 0xffff);
Mark Lord32cd11a2009-02-01 16:50:32 -05001788 mv_sg->reserved = 0;
Olof Johansson4007b492007-10-02 20:45:27 -05001789
1790 sg_len -= len;
1791 addr += len;
1792
Jeff Garzik3be6cbd2007-10-18 16:21:18 -04001793 last_sg = mv_sg;
Olof Johansson4007b492007-10-02 20:45:27 -05001794 mv_sg++;
Olof Johansson4007b492007-10-02 20:45:27 -05001795 }
Brett Russ31961942005-09-30 01:36:00 -04001796 }
Jeff Garzik3be6cbd2007-10-18 16:21:18 -04001797
1798 if (likely(last_sg))
1799 last_sg->flags_size |= cpu_to_le32(EPRD_FLAG_END_OF_TBL);
Mark Lord32cd11a2009-02-01 16:50:32 -05001800 mb(); /* ensure data structure is visible to the chipset */
Brett Russ31961942005-09-30 01:36:00 -04001801}
1802
Jeff Garzik5796d1c2007-10-26 00:03:37 -04001803static void mv_crqb_pack_cmd(__le16 *cmdw, u8 data, u8 addr, unsigned last)
Brett Russ31961942005-09-30 01:36:00 -04001804{
Mark Lord559eeda2006-05-19 16:40:15 -04001805 u16 tmp = data | (addr << CRQB_CMD_ADDR_SHIFT) | CRQB_CMD_CS |
Brett Russ31961942005-09-30 01:36:00 -04001806 (last ? CRQB_CMD_LAST : 0);
Mark Lord559eeda2006-05-19 16:40:15 -04001807 *cmdw = cpu_to_le16(tmp);
Brett Russ31961942005-09-30 01:36:00 -04001808}
1809
Brett Russ05b308e2005-10-05 17:08:53 -04001810/**
Mark Lordda142652009-01-30 18:51:54 -05001811 * mv_sff_irq_clear - Clear hardware interrupt after DMA.
1812 * @ap: Port associated with this ATA transaction.
1813 *
1814 * We need this only for ATAPI bmdma transactions,
1815 * as otherwise we experience spurious interrupts
1816 * after libata-sff handles the bmdma interrupts.
1817 */
1818static void mv_sff_irq_clear(struct ata_port *ap)
1819{
1820 mv_clear_and_enable_port_irqs(ap, mv_ap_base(ap), ERR_IRQ);
1821}
1822
1823/**
1824 * mv_check_atapi_dma - Filter ATAPI cmds which are unsuitable for DMA.
1825 * @qc: queued command to check for chipset/DMA compatibility.
1826 *
1827 * The bmdma engines cannot handle speculative data sizes
1828 * (bytecount under/over flow). So only allow DMA for
1829 * data transfer commands with known data sizes.
1830 *
1831 * LOCKING:
1832 * Inherited from caller.
1833 */
1834static int mv_check_atapi_dma(struct ata_queued_cmd *qc)
1835{
1836 struct scsi_cmnd *scmd = qc->scsicmd;
1837
1838 if (scmd) {
1839 switch (scmd->cmnd[0]) {
1840 case READ_6:
1841 case READ_10:
1842 case READ_12:
1843 case WRITE_6:
1844 case WRITE_10:
1845 case WRITE_12:
1846 case GPCMD_READ_CD:
1847 case GPCMD_SEND_DVD_STRUCTURE:
1848 case GPCMD_SEND_CUE_SHEET:
1849 return 0; /* DMA is safe */
1850 }
1851 }
1852 return -EOPNOTSUPP; /* use PIO instead */
1853}
1854
1855/**
1856 * mv_bmdma_setup - Set up BMDMA transaction
1857 * @qc: queued command to prepare DMA for.
1858 *
1859 * LOCKING:
1860 * Inherited from caller.
1861 */
1862static void mv_bmdma_setup(struct ata_queued_cmd *qc)
1863{
1864 struct ata_port *ap = qc->ap;
1865 void __iomem *port_mmio = mv_ap_base(ap);
1866 struct mv_port_priv *pp = ap->private_data;
1867
1868 mv_fill_sg(qc);
1869
1870 /* clear all DMA cmd bits */
Mark Lordcae5a292009-04-06 16:43:45 -04001871 writel(0, port_mmio + BMDMA_CMD);
Mark Lordda142652009-01-30 18:51:54 -05001872
1873 /* load PRD table addr. */
1874 writel((pp->sg_tbl_dma[qc->tag] >> 16) >> 16,
Mark Lordcae5a292009-04-06 16:43:45 -04001875 port_mmio + BMDMA_PRD_HIGH);
Mark Lordda142652009-01-30 18:51:54 -05001876 writelfl(pp->sg_tbl_dma[qc->tag],
Mark Lordcae5a292009-04-06 16:43:45 -04001877 port_mmio + BMDMA_PRD_LOW);
Mark Lordda142652009-01-30 18:51:54 -05001878
1879 /* issue r/w command */
1880 ap->ops->sff_exec_command(ap, &qc->tf);
1881}
1882
1883/**
1884 * mv_bmdma_start - Start a BMDMA transaction
1885 * @qc: queued command to start DMA on.
1886 *
1887 * LOCKING:
1888 * Inherited from caller.
1889 */
1890static void mv_bmdma_start(struct ata_queued_cmd *qc)
1891{
1892 struct ata_port *ap = qc->ap;
1893 void __iomem *port_mmio = mv_ap_base(ap);
1894 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
1895 u32 cmd = (rw ? 0 : ATA_DMA_WR) | ATA_DMA_START;
1896
1897 /* start host DMA transaction */
Mark Lordcae5a292009-04-06 16:43:45 -04001898 writelfl(cmd, port_mmio + BMDMA_CMD);
Mark Lordda142652009-01-30 18:51:54 -05001899}
1900
1901/**
1902 * mv_bmdma_stop - Stop BMDMA transfer
1903 * @qc: queued command to stop DMA on.
1904 *
1905 * Clears the ATA_DMA_START flag in the bmdma control register
1906 *
1907 * LOCKING:
1908 * Inherited from caller.
1909 */
Mark Lord44b73382010-08-19 21:40:44 -04001910static void mv_bmdma_stop_ap(struct ata_port *ap)
Mark Lordda142652009-01-30 18:51:54 -05001911{
Mark Lordda142652009-01-30 18:51:54 -05001912 void __iomem *port_mmio = mv_ap_base(ap);
1913 u32 cmd;
1914
1915 /* clear start/stop bit */
Mark Lordcae5a292009-04-06 16:43:45 -04001916 cmd = readl(port_mmio + BMDMA_CMD);
Mark Lord44b73382010-08-19 21:40:44 -04001917 if (cmd & ATA_DMA_START) {
1918 cmd &= ~ATA_DMA_START;
1919 writelfl(cmd, port_mmio + BMDMA_CMD);
Mark Lordda142652009-01-30 18:51:54 -05001920
Mark Lord44b73382010-08-19 21:40:44 -04001921 /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
1922 ata_sff_dma_pause(ap);
1923 }
1924}
1925
1926static void mv_bmdma_stop(struct ata_queued_cmd *qc)
1927{
1928 mv_bmdma_stop_ap(qc->ap);
Mark Lordda142652009-01-30 18:51:54 -05001929}
1930
1931/**
1932 * mv_bmdma_status - Read BMDMA status
1933 * @ap: port for which to retrieve DMA status.
1934 *
1935 * Read and return equivalent of the sff BMDMA status register.
1936 *
1937 * LOCKING:
1938 * Inherited from caller.
1939 */
1940static u8 mv_bmdma_status(struct ata_port *ap)
1941{
1942 void __iomem *port_mmio = mv_ap_base(ap);
1943 u32 reg, status;
1944
1945 /*
1946 * Other bits are valid only if ATA_DMA_ACTIVE==0,
1947 * and the ATA_DMA_INTR bit doesn't exist.
1948 */
Mark Lordcae5a292009-04-06 16:43:45 -04001949 reg = readl(port_mmio + BMDMA_STATUS);
Mark Lordda142652009-01-30 18:51:54 -05001950 if (reg & ATA_DMA_ACTIVE)
1951 status = ATA_DMA_ACTIVE;
Mark Lord44b73382010-08-19 21:40:44 -04001952 else if (reg & ATA_DMA_ERR)
Mark Lordda142652009-01-30 18:51:54 -05001953 status = (reg & ATA_DMA_ERR) | ATA_DMA_INTR;
Mark Lord44b73382010-08-19 21:40:44 -04001954 else {
1955 /*
1956 * Just because DMA_ACTIVE is 0 (DMA completed),
1957 * this does _not_ mean the device is "done".
1958 * So we should not yet be signalling ATA_DMA_INTR
1959 * in some cases. Eg. DSM/TRIM, and perhaps others.
1960 */
1961 mv_bmdma_stop_ap(ap);
1962 if (ioread8(ap->ioaddr.altstatus_addr) & ATA_BUSY)
1963 status = 0;
1964 else
1965 status = ATA_DMA_INTR;
1966 }
Mark Lordda142652009-01-30 18:51:54 -05001967 return status;
1968}
1969
Mark Lord299b3f82009-04-13 11:29:34 -04001970static void mv_rw_multi_errata_sata24(struct ata_queued_cmd *qc)
1971{
1972 struct ata_taskfile *tf = &qc->tf;
1973 /*
1974 * Workaround for 88SX60x1 FEr SATA#24.
1975 *
1976 * Chip may corrupt WRITEs if multi_count >= 4kB.
1977 * Note that READs are unaffected.
1978 *
1979 * It's not clear if this errata really means "4K bytes",
1980 * or if it always happens for multi_count > 7
1981 * regardless of device sector_size.
1982 *
1983 * So, for safety, any write with multi_count > 7
1984 * gets converted here into a regular PIO write instead:
1985 */
1986 if ((tf->flags & ATA_TFLAG_WRITE) && is_multi_taskfile(tf)) {
1987 if (qc->dev->multi_count > 7) {
1988 switch (tf->command) {
1989 case ATA_CMD_WRITE_MULTI:
1990 tf->command = ATA_CMD_PIO_WRITE;
1991 break;
1992 case ATA_CMD_WRITE_MULTI_FUA_EXT:
1993 tf->flags &= ~ATA_TFLAG_FUA; /* ugh */
1994 /* fall through */
1995 case ATA_CMD_WRITE_MULTI_EXT:
1996 tf->command = ATA_CMD_PIO_WRITE_EXT;
1997 break;
1998 }
1999 }
2000 }
2001}
2002
Mark Lordda142652009-01-30 18:51:54 -05002003/**
Brett Russ05b308e2005-10-05 17:08:53 -04002004 * mv_qc_prep - Host specific command preparation.
2005 * @qc: queued command to prepare
2006 *
2007 * This routine simply redirects to the general purpose routine
2008 * if command is not DMA. Else, it handles prep of the CRQB
2009 * (command request block), does some sanity checking, and calls
2010 * the SG load routine.
2011 *
2012 * LOCKING:
2013 * Inherited from caller.
2014 */
Brett Russ31961942005-09-30 01:36:00 -04002015static void mv_qc_prep(struct ata_queued_cmd *qc)
2016{
2017 struct ata_port *ap = qc->ap;
2018 struct mv_port_priv *pp = ap->private_data;
Mark Lorde1469872006-05-22 19:02:03 -04002019 __le16 *cw;
Mark Lord8d2b4502009-04-13 11:27:18 -04002020 struct ata_taskfile *tf = &qc->tf;
Brett Russ31961942005-09-30 01:36:00 -04002021 u16 flags = 0;
Mark Lorda6432432006-05-19 16:36:36 -04002022 unsigned in_index;
Brett Russ31961942005-09-30 01:36:00 -04002023
Mark Lord299b3f82009-04-13 11:29:34 -04002024 switch (tf->protocol) {
2025 case ATA_PROT_DMA:
Mark Lord44b73382010-08-19 21:40:44 -04002026 if (tf->command == ATA_CMD_DSM)
2027 return;
2028 /* fall-thru */
Mark Lord299b3f82009-04-13 11:29:34 -04002029 case ATA_PROT_NCQ:
2030 break; /* continue below */
2031 case ATA_PROT_PIO:
2032 mv_rw_multi_errata_sata24(qc);
Brett Russ31961942005-09-30 01:36:00 -04002033 return;
Mark Lord299b3f82009-04-13 11:29:34 -04002034 default:
2035 return;
2036 }
Brett Russ20f733e2005-09-01 18:26:17 -04002037
Brett Russ31961942005-09-30 01:36:00 -04002038 /* Fill in command request block
2039 */
Mark Lord8d2b4502009-04-13 11:27:18 -04002040 if (!(tf->flags & ATA_TFLAG_WRITE))
Brett Russ31961942005-09-30 01:36:00 -04002041 flags |= CRQB_FLAG_READ;
Tejun Heobeec7db2006-02-11 19:11:13 +09002042 WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
Brett Russ31961942005-09-30 01:36:00 -04002043 flags |= qc->tag << CRQB_TAG_SHIFT;
Mark Lorde49856d2008-04-16 14:59:07 -04002044 flags |= (qc->dev->link->pmp & 0xf) << CRQB_PMP_SHIFT;
Brett Russ31961942005-09-30 01:36:00 -04002045
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002046 /* get current queue index from software */
Mark Lordfcfb1f72008-04-19 15:06:40 -04002047 in_index = pp->req_idx;
Brett Russ31961942005-09-30 01:36:00 -04002048
Mark Lorda6432432006-05-19 16:36:36 -04002049 pp->crqb[in_index].sg_addr =
Mark Lordeb73d552008-01-29 13:24:00 -05002050 cpu_to_le32(pp->sg_tbl_dma[qc->tag] & 0xffffffff);
Mark Lorda6432432006-05-19 16:36:36 -04002051 pp->crqb[in_index].sg_addr_hi =
Mark Lordeb73d552008-01-29 13:24:00 -05002052 cpu_to_le32((pp->sg_tbl_dma[qc->tag] >> 16) >> 16);
Mark Lorda6432432006-05-19 16:36:36 -04002053 pp->crqb[in_index].ctrl_flags = cpu_to_le16(flags);
2054
2055 cw = &pp->crqb[in_index].ata_cmd[0];
Brett Russ31961942005-09-30 01:36:00 -04002056
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002057 /* Sadly, the CRQB cannot accommodate all registers--there are
Brett Russ31961942005-09-30 01:36:00 -04002058 * only 11 bytes...so we must pick and choose required
2059 * registers based on the command. So, we drop feature and
2060 * hob_feature for [RW] DMA commands, but they are needed for
Mark Lordcd12e1f2009-01-19 18:06:28 -05002061 * NCQ. NCQ will drop hob_nsect, which is not needed there
2062 * (nsect is used only for the tag; feat/hob_feat hold true nsect).
Brett Russ31961942005-09-30 01:36:00 -04002063 */
2064 switch (tf->command) {
2065 case ATA_CMD_READ:
2066 case ATA_CMD_READ_EXT:
2067 case ATA_CMD_WRITE:
2068 case ATA_CMD_WRITE_EXT:
Jens Axboec15d85c2006-02-15 15:59:25 +01002069 case ATA_CMD_WRITE_FUA_EXT:
Brett Russ31961942005-09-30 01:36:00 -04002070 mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
2071 break;
Brett Russ31961942005-09-30 01:36:00 -04002072 case ATA_CMD_FPDMA_READ:
2073 case ATA_CMD_FPDMA_WRITE:
Jeff Garzik8b260242005-11-12 12:32:50 -05002074 mv_crqb_pack_cmd(cw++, tf->hob_feature, ATA_REG_FEATURE, 0);
Brett Russ31961942005-09-30 01:36:00 -04002075 mv_crqb_pack_cmd(cw++, tf->feature, ATA_REG_FEATURE, 0);
2076 break;
Brett Russ31961942005-09-30 01:36:00 -04002077 default:
2078 /* The only other commands EDMA supports in non-queued and
2079 * non-NCQ mode are: [RW] STREAM DMA and W DMA FUA EXT, none
2080 * of which are defined/used by Linux. If we get here, this
2081 * driver needs work.
2082 *
2083 * FIXME: modify libata to give qc_prep a return value and
2084 * return error here.
2085 */
2086 BUG_ON(tf->command);
2087 break;
2088 }
2089 mv_crqb_pack_cmd(cw++, tf->nsect, ATA_REG_NSECT, 0);
2090 mv_crqb_pack_cmd(cw++, tf->hob_lbal, ATA_REG_LBAL, 0);
2091 mv_crqb_pack_cmd(cw++, tf->lbal, ATA_REG_LBAL, 0);
2092 mv_crqb_pack_cmd(cw++, tf->hob_lbam, ATA_REG_LBAM, 0);
2093 mv_crqb_pack_cmd(cw++, tf->lbam, ATA_REG_LBAM, 0);
2094 mv_crqb_pack_cmd(cw++, tf->hob_lbah, ATA_REG_LBAH, 0);
2095 mv_crqb_pack_cmd(cw++, tf->lbah, ATA_REG_LBAH, 0);
2096 mv_crqb_pack_cmd(cw++, tf->device, ATA_REG_DEVICE, 0);
2097 mv_crqb_pack_cmd(cw++, tf->command, ATA_REG_CMD, 1); /* last */
2098
Jeff Garzike4e7b892006-01-31 12:18:41 -05002099 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
Brett Russ31961942005-09-30 01:36:00 -04002100 return;
Jeff Garzike4e7b892006-01-31 12:18:41 -05002101 mv_fill_sg(qc);
2102}
2103
2104/**
2105 * mv_qc_prep_iie - Host specific command preparation.
2106 * @qc: queued command to prepare
2107 *
2108 * This routine simply redirects to the general purpose routine
2109 * if command is not DMA. Else, it handles prep of the CRQB
2110 * (command request block), does some sanity checking, and calls
2111 * the SG load routine.
2112 *
2113 * LOCKING:
2114 * Inherited from caller.
2115 */
2116static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
2117{
2118 struct ata_port *ap = qc->ap;
2119 struct mv_port_priv *pp = ap->private_data;
2120 struct mv_crqb_iie *crqb;
Mark Lord8d2b4502009-04-13 11:27:18 -04002121 struct ata_taskfile *tf = &qc->tf;
Mark Lorda6432432006-05-19 16:36:36 -04002122 unsigned in_index;
Jeff Garzike4e7b892006-01-31 12:18:41 -05002123 u32 flags = 0;
2124
Mark Lord8d2b4502009-04-13 11:27:18 -04002125 if ((tf->protocol != ATA_PROT_DMA) &&
2126 (tf->protocol != ATA_PROT_NCQ))
Jeff Garzike4e7b892006-01-31 12:18:41 -05002127 return;
Mark Lord44b73382010-08-19 21:40:44 -04002128 if (tf->command == ATA_CMD_DSM)
2129 return; /* use bmdma for this */
Jeff Garzike4e7b892006-01-31 12:18:41 -05002130
Mark Lorde12bef52008-03-31 19:33:56 -04002131 /* Fill in Gen IIE command request block */
Mark Lord8d2b4502009-04-13 11:27:18 -04002132 if (!(tf->flags & ATA_TFLAG_WRITE))
Jeff Garzike4e7b892006-01-31 12:18:41 -05002133 flags |= CRQB_FLAG_READ;
2134
Tejun Heobeec7db2006-02-11 19:11:13 +09002135 WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
Jeff Garzike4e7b892006-01-31 12:18:41 -05002136 flags |= qc->tag << CRQB_TAG_SHIFT;
Mark Lord8c0aeb42008-01-26 18:31:48 -05002137 flags |= qc->tag << CRQB_HOSTQ_SHIFT;
Mark Lorde49856d2008-04-16 14:59:07 -04002138 flags |= (qc->dev->link->pmp & 0xf) << CRQB_PMP_SHIFT;
Jeff Garzike4e7b892006-01-31 12:18:41 -05002139
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002140 /* get current queue index from software */
Mark Lordfcfb1f72008-04-19 15:06:40 -04002141 in_index = pp->req_idx;
Mark Lorda6432432006-05-19 16:36:36 -04002142
2143 crqb = (struct mv_crqb_iie *) &pp->crqb[in_index];
Mark Lordeb73d552008-01-29 13:24:00 -05002144 crqb->addr = cpu_to_le32(pp->sg_tbl_dma[qc->tag] & 0xffffffff);
2145 crqb->addr_hi = cpu_to_le32((pp->sg_tbl_dma[qc->tag] >> 16) >> 16);
Jeff Garzike4e7b892006-01-31 12:18:41 -05002146 crqb->flags = cpu_to_le32(flags);
2147
Jeff Garzike4e7b892006-01-31 12:18:41 -05002148 crqb->ata_cmd[0] = cpu_to_le32(
2149 (tf->command << 16) |
2150 (tf->feature << 24)
2151 );
2152 crqb->ata_cmd[1] = cpu_to_le32(
2153 (tf->lbal << 0) |
2154 (tf->lbam << 8) |
2155 (tf->lbah << 16) |
2156 (tf->device << 24)
2157 );
2158 crqb->ata_cmd[2] = cpu_to_le32(
2159 (tf->hob_lbal << 0) |
2160 (tf->hob_lbam << 8) |
2161 (tf->hob_lbah << 16) |
2162 (tf->hob_feature << 24)
2163 );
2164 crqb->ata_cmd[3] = cpu_to_le32(
2165 (tf->nsect << 0) |
2166 (tf->hob_nsect << 8)
2167 );
2168
2169 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2170 return;
Brett Russ31961942005-09-30 01:36:00 -04002171 mv_fill_sg(qc);
2172}
2173
Brett Russ05b308e2005-10-05 17:08:53 -04002174/**
Mark Lordd16ab3f2009-02-25 15:17:43 -05002175 * mv_sff_check_status - fetch device status, if valid
2176 * @ap: ATA port to fetch status from
2177 *
2178 * When using command issue via mv_qc_issue_fis(),
2179 * the initial ATA_BUSY state does not show up in the
2180 * ATA status (shadow) register. This can confuse libata!
2181 *
2182 * So we have a hook here to fake ATA_BUSY for that situation,
2183 * until the first time a BUSY, DRQ, or ERR bit is seen.
2184 *
2185 * The rest of the time, it simply returns the ATA status register.
2186 */
2187static u8 mv_sff_check_status(struct ata_port *ap)
2188{
2189 u8 stat = ioread8(ap->ioaddr.status_addr);
2190 struct mv_port_priv *pp = ap->private_data;
2191
2192 if (pp->pp_flags & MV_PP_FLAG_FAKE_ATA_BUSY) {
2193 if (stat & (ATA_BUSY | ATA_DRQ | ATA_ERR))
2194 pp->pp_flags &= ~MV_PP_FLAG_FAKE_ATA_BUSY;
2195 else
2196 stat = ATA_BUSY;
2197 }
2198 return stat;
2199}
2200
2201/**
Mark Lord70f8b792009-02-25 15:19:20 -05002202 * mv_send_fis - Send a FIS, using the "Vendor-Unique FIS" register
2203 * @fis: fis to be sent
2204 * @nwords: number of 32-bit words in the fis
2205 */
2206static unsigned int mv_send_fis(struct ata_port *ap, u32 *fis, int nwords)
2207{
2208 void __iomem *port_mmio = mv_ap_base(ap);
2209 u32 ifctl, old_ifctl, ifstat;
2210 int i, timeout = 200, final_word = nwords - 1;
2211
2212 /* Initiate FIS transmission mode */
Mark Lordcae5a292009-04-06 16:43:45 -04002213 old_ifctl = readl(port_mmio + SATA_IFCTL);
Mark Lord70f8b792009-02-25 15:19:20 -05002214 ifctl = 0x100 | (old_ifctl & 0xf);
Mark Lordcae5a292009-04-06 16:43:45 -04002215 writelfl(ifctl, port_mmio + SATA_IFCTL);
Mark Lord70f8b792009-02-25 15:19:20 -05002216
2217 /* Send all words of the FIS except for the final word */
2218 for (i = 0; i < final_word; ++i)
Mark Lordcae5a292009-04-06 16:43:45 -04002219 writel(fis[i], port_mmio + VENDOR_UNIQUE_FIS);
Mark Lord70f8b792009-02-25 15:19:20 -05002220
2221 /* Flag end-of-transmission, and then send the final word */
Mark Lordcae5a292009-04-06 16:43:45 -04002222 writelfl(ifctl | 0x200, port_mmio + SATA_IFCTL);
2223 writelfl(fis[final_word], port_mmio + VENDOR_UNIQUE_FIS);
Mark Lord70f8b792009-02-25 15:19:20 -05002224
2225 /*
2226 * Wait for FIS transmission to complete.
2227 * This typically takes just a single iteration.
2228 */
2229 do {
Mark Lordcae5a292009-04-06 16:43:45 -04002230 ifstat = readl(port_mmio + SATA_IFSTAT);
Mark Lord70f8b792009-02-25 15:19:20 -05002231 } while (!(ifstat & 0x1000) && --timeout);
2232
2233 /* Restore original port configuration */
Mark Lordcae5a292009-04-06 16:43:45 -04002234 writelfl(old_ifctl, port_mmio + SATA_IFCTL);
Mark Lord70f8b792009-02-25 15:19:20 -05002235
2236 /* See if it worked */
2237 if ((ifstat & 0x3000) != 0x1000) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002238 ata_port_warn(ap, "%s transmission error, ifstat=%08x\n",
2239 __func__, ifstat);
Mark Lord70f8b792009-02-25 15:19:20 -05002240 return AC_ERR_OTHER;
2241 }
2242 return 0;
2243}
2244
2245/**
2246 * mv_qc_issue_fis - Issue a command directly as a FIS
2247 * @qc: queued command to start
2248 *
2249 * Note that the ATA shadow registers are not updated
2250 * after command issue, so the device will appear "READY"
2251 * if polled, even while it is BUSY processing the command.
2252 *
2253 * So we use a status hook to fake ATA_BUSY until the drive changes state.
2254 *
2255 * Note: we don't get updated shadow regs on *completion*
2256 * of non-data commands. So avoid sending them via this function,
2257 * as they will appear to have completed immediately.
2258 *
2259 * GEN_IIE has special registers that we could get the result tf from,
2260 * but earlier chipsets do not. For now, we ignore those registers.
2261 */
2262static unsigned int mv_qc_issue_fis(struct ata_queued_cmd *qc)
2263{
2264 struct ata_port *ap = qc->ap;
2265 struct mv_port_priv *pp = ap->private_data;
2266 struct ata_link *link = qc->dev->link;
2267 u32 fis[5];
2268 int err = 0;
2269
2270 ata_tf_to_fis(&qc->tf, link->pmp, 1, (void *)fis);
Thiago Farina4c4a90f2009-11-08 14:30:57 -05002271 err = mv_send_fis(ap, fis, ARRAY_SIZE(fis));
Mark Lord70f8b792009-02-25 15:19:20 -05002272 if (err)
2273 return err;
2274
2275 switch (qc->tf.protocol) {
2276 case ATAPI_PROT_PIO:
2277 pp->pp_flags |= MV_PP_FLAG_FAKE_ATA_BUSY;
2278 /* fall through */
2279 case ATAPI_PROT_NODATA:
2280 ap->hsm_task_state = HSM_ST_FIRST;
2281 break;
2282 case ATA_PROT_PIO:
2283 pp->pp_flags |= MV_PP_FLAG_FAKE_ATA_BUSY;
2284 if (qc->tf.flags & ATA_TFLAG_WRITE)
2285 ap->hsm_task_state = HSM_ST_FIRST;
2286 else
2287 ap->hsm_task_state = HSM_ST;
2288 break;
2289 default:
2290 ap->hsm_task_state = HSM_ST_LAST;
2291 break;
2292 }
2293
2294 if (qc->tf.flags & ATA_TFLAG_POLLING)
Gwendal Grignouea3c6452010-08-31 16:20:36 -07002295 ata_sff_queue_pio_task(link, 0);
Mark Lord70f8b792009-02-25 15:19:20 -05002296 return 0;
2297}
2298
2299/**
Brett Russ05b308e2005-10-05 17:08:53 -04002300 * mv_qc_issue - Initiate a command to the host
2301 * @qc: queued command to start
2302 *
2303 * This routine simply redirects to the general purpose routine
2304 * if command is not DMA. Else, it sanity checks our local
2305 * caches of the request producer/consumer indices then enables
2306 * DMA and bumps the request producer index.
2307 *
2308 * LOCKING:
2309 * Inherited from caller.
2310 */
Tejun Heo9a3d9eb2006-01-23 13:09:36 +09002311static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
Brett Russ31961942005-09-30 01:36:00 -04002312{
Mark Lordf48765c2009-01-30 18:48:41 -05002313 static int limit_warnings = 10;
Jeff Garzikc5d3e452007-07-11 18:30:50 -04002314 struct ata_port *ap = qc->ap;
2315 void __iomem *port_mmio = mv_ap_base(ap);
2316 struct mv_port_priv *pp = ap->private_data;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002317 u32 in_index;
Mark Lord42ed8932009-02-25 15:15:39 -05002318 unsigned int port_irqs;
Brett Russ31961942005-09-30 01:36:00 -04002319
Mark Lordd16ab3f2009-02-25 15:17:43 -05002320 pp->pp_flags &= ~MV_PP_FLAG_FAKE_ATA_BUSY; /* paranoia */
2321
Mark Lordf48765c2009-01-30 18:48:41 -05002322 switch (qc->tf.protocol) {
2323 case ATA_PROT_DMA:
Mark Lord44b73382010-08-19 21:40:44 -04002324 if (qc->tf.command == ATA_CMD_DSM) {
2325 if (!ap->ops->bmdma_setup) /* no bmdma on GEN_I */
2326 return AC_ERR_OTHER;
2327 break; /* use bmdma for this */
2328 }
2329 /* fall thru */
Mark Lordf48765c2009-01-30 18:48:41 -05002330 case ATA_PROT_NCQ:
2331 mv_start_edma(ap, port_mmio, pp, qc->tf.protocol);
2332 pp->req_idx = (pp->req_idx + 1) & MV_MAX_Q_DEPTH_MASK;
2333 in_index = pp->req_idx << EDMA_REQ_Q_PTR_SHIFT;
2334
2335 /* Write the request in pointer to kick the EDMA to life */
2336 writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | in_index,
Mark Lordcae5a292009-04-06 16:43:45 -04002337 port_mmio + EDMA_REQ_Q_IN_PTR);
Mark Lordf48765c2009-01-30 18:48:41 -05002338 return 0;
2339
2340 case ATA_PROT_PIO:
Mark Lordc6112bd2008-06-18 12:13:02 -04002341 /*
2342 * Errata SATA#16, SATA#24: warn if multiple DRQs expected.
2343 *
2344 * Someday, we might implement special polling workarounds
2345 * for these, but it all seems rather unnecessary since we
2346 * normally use only DMA for commands which transfer more
2347 * than a single block of data.
2348 *
2349 * Much of the time, this could just work regardless.
2350 * So for now, just log the incident, and allow the attempt.
2351 */
Mark Lordc7843e82008-06-18 21:57:42 -04002352 if (limit_warnings > 0 && (qc->nbytes / qc->sect_size) > 1) {
Mark Lordc6112bd2008-06-18 12:13:02 -04002353 --limit_warnings;
Joe Perchesa9a79df2011-04-15 15:51:59 -07002354 ata_link_warn(qc->dev->link, DRV_NAME
2355 ": attempting PIO w/multiple DRQ: "
2356 "this may fail due to h/w errata\n");
Mark Lordc6112bd2008-06-18 12:13:02 -04002357 }
Mark Lordf48765c2009-01-30 18:48:41 -05002358 /* drop through */
Mark Lord42ed8932009-02-25 15:15:39 -05002359 case ATA_PROT_NODATA:
Mark Lordf48765c2009-01-30 18:48:41 -05002360 case ATAPI_PROT_PIO:
Mark Lord42ed8932009-02-25 15:15:39 -05002361 case ATAPI_PROT_NODATA:
2362 if (ap->flags & ATA_FLAG_PIO_POLLING)
2363 qc->tf.flags |= ATA_TFLAG_POLLING;
2364 break;
Brett Russ31961942005-09-30 01:36:00 -04002365 }
Mark Lord42ed8932009-02-25 15:15:39 -05002366
2367 if (qc->tf.flags & ATA_TFLAG_POLLING)
2368 port_irqs = ERR_IRQ; /* mask device interrupt when polling */
2369 else
2370 port_irqs = ERR_IRQ | DONE_IRQ; /* unmask all interrupts */
2371
2372 /*
2373 * We're about to send a non-EDMA capable command to the
2374 * port. Turn off EDMA so there won't be problems accessing
2375 * shadow block, etc registers.
2376 */
2377 mv_stop_edma(ap);
2378 mv_clear_and_enable_port_irqs(ap, mv_ap_base(ap), port_irqs);
2379 mv_pmp_select(ap, qc->dev->link->pmp);
Mark Lord70f8b792009-02-25 15:19:20 -05002380
2381 if (qc->tf.command == ATA_CMD_READ_LOG_EXT) {
2382 struct mv_host_priv *hpriv = ap->host->private_data;
2383 /*
2384 * Workaround for 88SX60x1 FEr SATA#25 (part 2).
Mark Lord40f21b12009-03-10 18:51:04 -04002385 *
Mark Lord70f8b792009-02-25 15:19:20 -05002386 * After any NCQ error, the READ_LOG_EXT command
2387 * from libata-eh *must* use mv_qc_issue_fis().
2388 * Otherwise it might fail, due to chip errata.
2389 *
2390 * Rather than special-case it, we'll just *always*
2391 * use this method here for READ_LOG_EXT, making for
2392 * easier testing.
2393 */
2394 if (IS_GEN_II(hpriv))
2395 return mv_qc_issue_fis(qc);
2396 }
Tejun Heo360ff782010-05-10 21:41:42 +02002397 return ata_bmdma_qc_issue(qc);
Brett Russ31961942005-09-30 01:36:00 -04002398}
2399
Mark Lord8f767f82008-04-19 14:53:07 -04002400static struct ata_queued_cmd *mv_get_active_qc(struct ata_port *ap)
2401{
2402 struct mv_port_priv *pp = ap->private_data;
2403 struct ata_queued_cmd *qc;
2404
2405 if (pp->pp_flags & MV_PP_FLAG_NCQ_EN)
2406 return NULL;
2407 qc = ata_qc_from_tag(ap, ap->link.active_tag);
Tejun Heo3e4ec342010-05-10 21:41:30 +02002408 if (qc && !(qc->tf.flags & ATA_TFLAG_POLLING))
2409 return qc;
2410 return NULL;
Mark Lord8f767f82008-04-19 14:53:07 -04002411}
2412
Mark Lord29d187b2008-05-02 02:15:37 -04002413static void mv_pmp_error_handler(struct ata_port *ap)
2414{
2415 unsigned int pmp, pmp_map;
2416 struct mv_port_priv *pp = ap->private_data;
2417
2418 if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH) {
2419 /*
2420 * Perform NCQ error analysis on failed PMPs
2421 * before we freeze the port entirely.
2422 *
2423 * The failed PMPs are marked earlier by mv_pmp_eh_prep().
2424 */
2425 pmp_map = pp->delayed_eh_pmp_map;
2426 pp->pp_flags &= ~MV_PP_FLAG_DELAYED_EH;
2427 for (pmp = 0; pmp_map != 0; pmp++) {
2428 unsigned int this_pmp = (1 << pmp);
2429 if (pmp_map & this_pmp) {
2430 struct ata_link *link = &ap->pmp_link[pmp];
2431 pmp_map &= ~this_pmp;
2432 ata_eh_analyze_ncq_error(link);
2433 }
2434 }
2435 ata_port_freeze(ap);
2436 }
2437 sata_pmp_error_handler(ap);
2438}
2439
Mark Lord4c299ca2008-05-02 02:16:20 -04002440static unsigned int mv_get_err_pmp_map(struct ata_port *ap)
2441{
2442 void __iomem *port_mmio = mv_ap_base(ap);
2443
Mark Lordcae5a292009-04-06 16:43:45 -04002444 return readl(port_mmio + SATA_TESTCTL) >> 16;
Mark Lord4c299ca2008-05-02 02:16:20 -04002445}
2446
Mark Lord4c299ca2008-05-02 02:16:20 -04002447static void mv_pmp_eh_prep(struct ata_port *ap, unsigned int pmp_map)
2448{
2449 struct ata_eh_info *ehi;
2450 unsigned int pmp;
2451
2452 /*
2453 * Initialize EH info for PMPs which saw device errors
2454 */
2455 ehi = &ap->link.eh_info;
2456 for (pmp = 0; pmp_map != 0; pmp++) {
2457 unsigned int this_pmp = (1 << pmp);
2458 if (pmp_map & this_pmp) {
2459 struct ata_link *link = &ap->pmp_link[pmp];
2460
2461 pmp_map &= ~this_pmp;
2462 ehi = &link->eh_info;
2463 ata_ehi_clear_desc(ehi);
2464 ata_ehi_push_desc(ehi, "dev err");
2465 ehi->err_mask |= AC_ERR_DEV;
2466 ehi->action |= ATA_EH_RESET;
2467 ata_link_abort(link);
2468 }
2469 }
2470}
2471
Mark Lord06aaca32008-05-19 09:01:24 -04002472static int mv_req_q_empty(struct ata_port *ap)
2473{
2474 void __iomem *port_mmio = mv_ap_base(ap);
2475 u32 in_ptr, out_ptr;
2476
Mark Lordcae5a292009-04-06 16:43:45 -04002477 in_ptr = (readl(port_mmio + EDMA_REQ_Q_IN_PTR)
Mark Lord06aaca32008-05-19 09:01:24 -04002478 >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
Mark Lordcae5a292009-04-06 16:43:45 -04002479 out_ptr = (readl(port_mmio + EDMA_REQ_Q_OUT_PTR)
Mark Lord06aaca32008-05-19 09:01:24 -04002480 >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
2481 return (in_ptr == out_ptr); /* 1 == queue_is_empty */
2482}
2483
Mark Lord4c299ca2008-05-02 02:16:20 -04002484static int mv_handle_fbs_ncq_dev_err(struct ata_port *ap)
2485{
2486 struct mv_port_priv *pp = ap->private_data;
2487 int failed_links;
2488 unsigned int old_map, new_map;
2489
2490 /*
2491 * Device error during FBS+NCQ operation:
2492 *
2493 * Set a port flag to prevent further I/O being enqueued.
2494 * Leave the EDMA running to drain outstanding commands from this port.
2495 * Perform the post-mortem/EH only when all responses are complete.
2496 * Follow recovery sequence from 6042/7042 datasheet (7.3.15.4.2.2).
2497 */
2498 if (!(pp->pp_flags & MV_PP_FLAG_DELAYED_EH)) {
2499 pp->pp_flags |= MV_PP_FLAG_DELAYED_EH;
2500 pp->delayed_eh_pmp_map = 0;
2501 }
2502 old_map = pp->delayed_eh_pmp_map;
2503 new_map = old_map | mv_get_err_pmp_map(ap);
2504
2505 if (old_map != new_map) {
2506 pp->delayed_eh_pmp_map = new_map;
2507 mv_pmp_eh_prep(ap, new_map & ~old_map);
2508 }
Mark Lordc46938c2008-05-02 14:02:28 -04002509 failed_links = hweight16(new_map);
Mark Lord4c299ca2008-05-02 02:16:20 -04002510
Joe Perchesa9a79df2011-04-15 15:51:59 -07002511 ata_port_info(ap,
2512 "%s: pmp_map=%04x qc_map=%04x failed_links=%d nr_active_links=%d\n",
2513 __func__, pp->delayed_eh_pmp_map,
2514 ap->qc_active, failed_links,
2515 ap->nr_active_links);
Mark Lord4c299ca2008-05-02 02:16:20 -04002516
Mark Lord06aaca32008-05-19 09:01:24 -04002517 if (ap->nr_active_links <= failed_links && mv_req_q_empty(ap)) {
Mark Lord4c299ca2008-05-02 02:16:20 -04002518 mv_process_crpb_entries(ap, pp);
2519 mv_stop_edma(ap);
2520 mv_eh_freeze(ap);
Joe Perchesa9a79df2011-04-15 15:51:59 -07002521 ata_port_info(ap, "%s: done\n", __func__);
Mark Lord4c299ca2008-05-02 02:16:20 -04002522 return 1; /* handled */
2523 }
Joe Perchesa9a79df2011-04-15 15:51:59 -07002524 ata_port_info(ap, "%s: waiting\n", __func__);
Mark Lord4c299ca2008-05-02 02:16:20 -04002525 return 1; /* handled */
2526}
2527
2528static int mv_handle_fbs_non_ncq_dev_err(struct ata_port *ap)
2529{
2530 /*
2531 * Possible future enhancement:
2532 *
2533 * FBS+non-NCQ operation is not yet implemented.
2534 * See related notes in mv_edma_cfg().
2535 *
2536 * Device error during FBS+non-NCQ operation:
2537 *
2538 * We need to snapshot the shadow registers for each failed command.
2539 * Follow recovery sequence from 6042/7042 datasheet (7.3.15.4.2.3).
2540 */
2541 return 0; /* not handled */
2542}
2543
2544static int mv_handle_dev_err(struct ata_port *ap, u32 edma_err_cause)
2545{
2546 struct mv_port_priv *pp = ap->private_data;
2547
2548 if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN))
2549 return 0; /* EDMA was not active: not handled */
2550 if (!(pp->pp_flags & MV_PP_FLAG_FBS_EN))
2551 return 0; /* FBS was not active: not handled */
2552
2553 if (!(edma_err_cause & EDMA_ERR_DEV))
2554 return 0; /* non DEV error: not handled */
2555 edma_err_cause &= ~EDMA_ERR_IRQ_TRANSIENT;
2556 if (edma_err_cause & ~(EDMA_ERR_DEV | EDMA_ERR_SELF_DIS))
2557 return 0; /* other problems: not handled */
2558
2559 if (pp->pp_flags & MV_PP_FLAG_NCQ_EN) {
2560 /*
2561 * EDMA should NOT have self-disabled for this case.
2562 * If it did, then something is wrong elsewhere,
2563 * and we cannot handle it here.
2564 */
2565 if (edma_err_cause & EDMA_ERR_SELF_DIS) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002566 ata_port_warn(ap, "%s: err_cause=0x%x pp_flags=0x%x\n",
2567 __func__, edma_err_cause, pp->pp_flags);
Mark Lord4c299ca2008-05-02 02:16:20 -04002568 return 0; /* not handled */
2569 }
2570 return mv_handle_fbs_ncq_dev_err(ap);
2571 } else {
2572 /*
2573 * EDMA should have self-disabled for this case.
2574 * If it did not, then something is wrong elsewhere,
2575 * and we cannot handle it here.
2576 */
2577 if (!(edma_err_cause & EDMA_ERR_SELF_DIS)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002578 ata_port_warn(ap, "%s: err_cause=0x%x pp_flags=0x%x\n",
2579 __func__, edma_err_cause, pp->pp_flags);
Mark Lord4c299ca2008-05-02 02:16:20 -04002580 return 0; /* not handled */
2581 }
2582 return mv_handle_fbs_non_ncq_dev_err(ap);
2583 }
2584 return 0; /* not handled */
2585}
2586
Mark Lorda9010322008-05-02 02:14:02 -04002587static void mv_unexpected_intr(struct ata_port *ap, int edma_was_enabled)
Mark Lord8f767f82008-04-19 14:53:07 -04002588{
Mark Lord8f767f82008-04-19 14:53:07 -04002589 struct ata_eh_info *ehi = &ap->link.eh_info;
Mark Lorda9010322008-05-02 02:14:02 -04002590 char *when = "idle";
Mark Lord8f767f82008-04-19 14:53:07 -04002591
Mark Lord8f767f82008-04-19 14:53:07 -04002592 ata_ehi_clear_desc(ehi);
Tejun Heo3e4ec342010-05-10 21:41:30 +02002593 if (edma_was_enabled) {
Mark Lorda9010322008-05-02 02:14:02 -04002594 when = "EDMA enabled";
Mark Lord8f767f82008-04-19 14:53:07 -04002595 } else {
2596 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
2597 if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
Mark Lorda9010322008-05-02 02:14:02 -04002598 when = "polling";
Mark Lord8f767f82008-04-19 14:53:07 -04002599 }
Mark Lorda9010322008-05-02 02:14:02 -04002600 ata_ehi_push_desc(ehi, "unexpected device interrupt while %s", when);
Mark Lord8f767f82008-04-19 14:53:07 -04002601 ehi->err_mask |= AC_ERR_OTHER;
2602 ehi->action |= ATA_EH_RESET;
2603 ata_port_freeze(ap);
2604}
2605
Brett Russ05b308e2005-10-05 17:08:53 -04002606/**
Brett Russ05b308e2005-10-05 17:08:53 -04002607 * mv_err_intr - Handle error interrupts on the port
2608 * @ap: ATA channel to manipulate
2609 *
Mark Lord8d073792008-04-19 15:07:49 -04002610 * Most cases require a full reset of the chip's state machine,
2611 * which also performs a COMRESET.
2612 * Also, if the port disabled DMA, update our cached copy to match.
Brett Russ05b308e2005-10-05 17:08:53 -04002613 *
2614 * LOCKING:
2615 * Inherited from caller.
2616 */
Mark Lord37b90462008-05-02 02:12:34 -04002617static void mv_err_intr(struct ata_port *ap)
Brett Russ20f733e2005-09-01 18:26:17 -04002618{
Brett Russ31961942005-09-30 01:36:00 -04002619 void __iomem *port_mmio = mv_ap_base(ap);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002620 u32 edma_err_cause, eh_freeze_mask, serr = 0;
Mark Lorde4006072008-05-14 09:19:30 -04002621 u32 fis_cause = 0;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002622 struct mv_port_priv *pp = ap->private_data;
2623 struct mv_host_priv *hpriv = ap->host->private_data;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002624 unsigned int action = 0, err_mask = 0;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002625 struct ata_eh_info *ehi = &ap->link.eh_info;
Mark Lord37b90462008-05-02 02:12:34 -04002626 struct ata_queued_cmd *qc;
2627 int abort = 0;
Brett Russ20f733e2005-09-01 18:26:17 -04002628
Mark Lord8d073792008-04-19 15:07:49 -04002629 /*
Mark Lord37b90462008-05-02 02:12:34 -04002630 * Read and clear the SError and err_cause bits.
Mark Lorde4006072008-05-14 09:19:30 -04002631 * For GenIIe, if EDMA_ERR_TRANS_IRQ_7 is set, we also must read/clear
2632 * the FIS_IRQ_CAUSE register before clearing edma_err_cause.
Mark Lord8d073792008-04-19 15:07:49 -04002633 */
Mark Lord37b90462008-05-02 02:12:34 -04002634 sata_scr_read(&ap->link, SCR_ERROR, &serr);
2635 sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
2636
Mark Lordcae5a292009-04-06 16:43:45 -04002637 edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE);
Mark Lorde4006072008-05-14 09:19:30 -04002638 if (IS_GEN_IIE(hpriv) && (edma_err_cause & EDMA_ERR_TRANS_IRQ_7)) {
Mark Lordcae5a292009-04-06 16:43:45 -04002639 fis_cause = readl(port_mmio + FIS_IRQ_CAUSE);
2640 writelfl(~fis_cause, port_mmio + FIS_IRQ_CAUSE);
Mark Lorde4006072008-05-14 09:19:30 -04002641 }
Mark Lordcae5a292009-04-06 16:43:45 -04002642 writelfl(~edma_err_cause, port_mmio + EDMA_ERR_IRQ_CAUSE);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002643
Mark Lord4c299ca2008-05-02 02:16:20 -04002644 if (edma_err_cause & EDMA_ERR_DEV) {
2645 /*
2646 * Device errors during FIS-based switching operation
2647 * require special handling.
2648 */
2649 if (mv_handle_dev_err(ap, edma_err_cause))
2650 return;
2651 }
2652
Mark Lord37b90462008-05-02 02:12:34 -04002653 qc = mv_get_active_qc(ap);
2654 ata_ehi_clear_desc(ehi);
2655 ata_ehi_push_desc(ehi, "edma_err_cause=%08x pp_flags=%08x",
2656 edma_err_cause, pp->pp_flags);
Mark Lorde4006072008-05-14 09:19:30 -04002657
Mark Lordc443c502008-05-14 09:24:39 -04002658 if (IS_GEN_IIE(hpriv) && (edma_err_cause & EDMA_ERR_TRANS_IRQ_7)) {
Mark Lorde4006072008-05-14 09:19:30 -04002659 ata_ehi_push_desc(ehi, "fis_cause=%08x", fis_cause);
Mark Lordcae5a292009-04-06 16:43:45 -04002660 if (fis_cause & FIS_IRQ_CAUSE_AN) {
Mark Lordc443c502008-05-14 09:24:39 -04002661 u32 ec = edma_err_cause &
2662 ~(EDMA_ERR_TRANS_IRQ_7 | EDMA_ERR_IRQ_TRANSIENT);
2663 sata_async_notification(ap);
2664 if (!ec)
2665 return; /* Just an AN; no need for the nukes */
2666 ata_ehi_push_desc(ehi, "SDB notify");
2667 }
2668 }
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002669 /*
Mark Lord352fab72008-04-19 14:43:42 -04002670 * All generations share these EDMA error cause bits:
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002671 */
Mark Lord37b90462008-05-02 02:12:34 -04002672 if (edma_err_cause & EDMA_ERR_DEV) {
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002673 err_mask |= AC_ERR_DEV;
Mark Lord37b90462008-05-02 02:12:34 -04002674 action |= ATA_EH_RESET;
2675 ata_ehi_push_desc(ehi, "dev error");
2676 }
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002677 if (edma_err_cause & (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR |
Jeff Garzik6c1153e2007-07-13 15:20:15 -04002678 EDMA_ERR_CRQB_PAR | EDMA_ERR_CRPB_PAR |
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002679 EDMA_ERR_INTRL_PAR)) {
2680 err_mask |= AC_ERR_ATA_BUS;
Tejun Heocf480622008-01-24 00:05:14 +09002681 action |= ATA_EH_RESET;
Tejun Heob64bbc32007-07-16 14:29:39 +09002682 ata_ehi_push_desc(ehi, "parity error");
Brett Russafb0edd2005-10-05 17:08:42 -04002683 }
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002684 if (edma_err_cause & (EDMA_ERR_DEV_DCON | EDMA_ERR_DEV_CON)) {
2685 ata_ehi_hotplugged(ehi);
2686 ata_ehi_push_desc(ehi, edma_err_cause & EDMA_ERR_DEV_DCON ?
Tejun Heob64bbc32007-07-16 14:29:39 +09002687 "dev disconnect" : "dev connect");
Tejun Heocf480622008-01-24 00:05:14 +09002688 action |= ATA_EH_RESET;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002689 }
2690
Mark Lord352fab72008-04-19 14:43:42 -04002691 /*
2692 * Gen-I has a different SELF_DIS bit,
2693 * different FREEZE bits, and no SERR bit:
2694 */
Jeff Garzikee9ccdf2007-07-12 15:51:22 -04002695 if (IS_GEN_I(hpriv)) {
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002696 eh_freeze_mask = EDMA_EH_FREEZE_5;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002697 if (edma_err_cause & EDMA_ERR_SELF_DIS_5) {
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002698 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
Tejun Heob64bbc32007-07-16 14:29:39 +09002699 ata_ehi_push_desc(ehi, "EDMA self-disable");
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002700 }
2701 } else {
2702 eh_freeze_mask = EDMA_EH_FREEZE;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002703 if (edma_err_cause & EDMA_ERR_SELF_DIS) {
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002704 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
Tejun Heob64bbc32007-07-16 14:29:39 +09002705 ata_ehi_push_desc(ehi, "EDMA self-disable");
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002706 }
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002707 if (edma_err_cause & EDMA_ERR_SERR) {
Mark Lord8d073792008-04-19 15:07:49 -04002708 ata_ehi_push_desc(ehi, "SError=%08x", serr);
2709 err_mask |= AC_ERR_ATA_BUS;
Tejun Heocf480622008-01-24 00:05:14 +09002710 action |= ATA_EH_RESET;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002711 }
2712 }
Brett Russ20f733e2005-09-01 18:26:17 -04002713
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002714 if (!err_mask) {
2715 err_mask = AC_ERR_OTHER;
Tejun Heocf480622008-01-24 00:05:14 +09002716 action |= ATA_EH_RESET;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002717 }
2718
2719 ehi->serror |= serr;
2720 ehi->action |= action;
2721
2722 if (qc)
2723 qc->err_mask |= err_mask;
2724 else
2725 ehi->err_mask |= err_mask;
2726
Mark Lord37b90462008-05-02 02:12:34 -04002727 if (err_mask == AC_ERR_DEV) {
2728 /*
2729 * Cannot do ata_port_freeze() here,
2730 * because it would kill PIO access,
2731 * which is needed for further diagnosis.
2732 */
2733 mv_eh_freeze(ap);
2734 abort = 1;
2735 } else if (edma_err_cause & eh_freeze_mask) {
2736 /*
2737 * Note to self: ata_port_freeze() calls ata_port_abort()
2738 */
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002739 ata_port_freeze(ap);
Mark Lord37b90462008-05-02 02:12:34 -04002740 } else {
2741 abort = 1;
2742 }
2743
2744 if (abort) {
2745 if (qc)
2746 ata_link_abort(qc->dev->link);
2747 else
2748 ata_port_abort(ap);
2749 }
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002750}
2751
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002752static bool mv_process_crpb_response(struct ata_port *ap,
Mark Lordfcfb1f72008-04-19 15:06:40 -04002753 struct mv_crpb *response, unsigned int tag, int ncq_enabled)
2754{
Tejun Heo752e3862010-06-25 15:02:59 +02002755 u8 ata_status;
2756 u16 edma_status = le16_to_cpu(response->flags);
Tejun Heo752e3862010-06-25 15:02:59 +02002757
2758 /*
2759 * edma_status from a response queue entry:
2760 * LSB is from EDMA_ERR_IRQ_CAUSE (non-NCQ only).
2761 * MSB is saved ATA status from command completion.
2762 */
2763 if (!ncq_enabled) {
2764 u8 err_cause = edma_status & 0xff & ~EDMA_ERR_DEV;
2765 if (err_cause) {
2766 /*
2767 * Error will be seen/handled by
2768 * mv_err_intr(). So do nothing at all here.
2769 */
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002770 return false;
Tejun Heo752e3862010-06-25 15:02:59 +02002771 }
2772 }
2773 ata_status = edma_status >> CRPB_FLAG_STATUS_SHIFT;
2774 if (!ac_err_mask(ata_status))
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002775 return true;
Tejun Heo752e3862010-06-25 15:02:59 +02002776 /* else: leave it for mv_err_intr() */
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002777 return false;
Mark Lordfcfb1f72008-04-19 15:06:40 -04002778}
2779
2780static void mv_process_crpb_entries(struct ata_port *ap, struct mv_port_priv *pp)
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002781{
2782 void __iomem *port_mmio = mv_ap_base(ap);
2783 struct mv_host_priv *hpriv = ap->host->private_data;
Mark Lordfcfb1f72008-04-19 15:06:40 -04002784 u32 in_index;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002785 bool work_done = false;
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002786 u32 done_mask = 0;
Mark Lordfcfb1f72008-04-19 15:06:40 -04002787 int ncq_enabled = (pp->pp_flags & MV_PP_FLAG_NCQ_EN);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002788
Mark Lordfcfb1f72008-04-19 15:06:40 -04002789 /* Get the hardware queue position index */
Mark Lordcae5a292009-04-06 16:43:45 -04002790 in_index = (readl(port_mmio + EDMA_RSP_Q_IN_PTR)
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002791 >> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
2792
Mark Lordfcfb1f72008-04-19 15:06:40 -04002793 /* Process new responses from since the last time we looked */
2794 while (in_index != pp->resp_idx) {
Jeff Garzik6c1153e2007-07-13 15:20:15 -04002795 unsigned int tag;
Mark Lordfcfb1f72008-04-19 15:06:40 -04002796 struct mv_crpb *response = &pp->crpb[pp->resp_idx];
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002797
Mark Lordfcfb1f72008-04-19 15:06:40 -04002798 pp->resp_idx = (pp->resp_idx + 1) & MV_MAX_Q_DEPTH_MASK;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002799
Mark Lordfcfb1f72008-04-19 15:06:40 -04002800 if (IS_GEN_I(hpriv)) {
2801 /* 50xx: no NCQ, only one command active at a time */
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002802 tag = ap->link.active_tag;
Mark Lordfcfb1f72008-04-19 15:06:40 -04002803 } else {
2804 /* Gen II/IIE: get command tag from CRPB entry */
2805 tag = le16_to_cpu(response->id) & 0x1f;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002806 }
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002807 if (mv_process_crpb_response(ap, response, tag, ncq_enabled))
2808 done_mask |= 1 << tag;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002809 work_done = true;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002810 }
2811
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002812 if (work_done) {
2813 ata_qc_complete_multiple(ap, ap->qc_active ^ done_mask);
2814
2815 /* Update the software queue position index in hardware */
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002816 writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) |
Mark Lordfcfb1f72008-04-19 15:06:40 -04002817 (pp->resp_idx << EDMA_RSP_Q_PTR_SHIFT),
Mark Lordcae5a292009-04-06 16:43:45 -04002818 port_mmio + EDMA_RSP_Q_OUT_PTR);
Tejun Heo1aadf5c2010-06-25 15:03:34 +02002819 }
Brett Russ20f733e2005-09-01 18:26:17 -04002820}
2821
Mark Lorda9010322008-05-02 02:14:02 -04002822static void mv_port_intr(struct ata_port *ap, u32 port_cause)
2823{
2824 struct mv_port_priv *pp;
2825 int edma_was_enabled;
2826
Mark Lorda9010322008-05-02 02:14:02 -04002827 /*
2828 * Grab a snapshot of the EDMA_EN flag setting,
2829 * so that we have a consistent view for this port,
2830 * even if something we call of our routines changes it.
2831 */
2832 pp = ap->private_data;
2833 edma_was_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
2834 /*
2835 * Process completed CRPB response(s) before other events.
2836 */
2837 if (edma_was_enabled && (port_cause & DONE_IRQ)) {
2838 mv_process_crpb_entries(ap, pp);
Mark Lord4c299ca2008-05-02 02:16:20 -04002839 if (pp->pp_flags & MV_PP_FLAG_DELAYED_EH)
2840 mv_handle_fbs_ncq_dev_err(ap);
Mark Lorda9010322008-05-02 02:14:02 -04002841 }
2842 /*
2843 * Handle chip-reported errors, or continue on to handle PIO.
2844 */
2845 if (unlikely(port_cause & ERR_IRQ)) {
2846 mv_err_intr(ap);
2847 } else if (!edma_was_enabled) {
2848 struct ata_queued_cmd *qc = mv_get_active_qc(ap);
2849 if (qc)
Tejun Heoc3b28892010-05-19 22:10:21 +02002850 ata_bmdma_port_intr(ap, qc);
Mark Lorda9010322008-05-02 02:14:02 -04002851 else
2852 mv_unexpected_intr(ap, edma_was_enabled);
2853 }
2854}
2855
Brett Russ05b308e2005-10-05 17:08:53 -04002856/**
2857 * mv_host_intr - Handle all interrupts on the given host controller
Jeff Garzikcca39742006-08-24 03:19:22 -04002858 * @host: host specific structure
Mark Lord7368f912008-04-25 11:24:24 -04002859 * @main_irq_cause: Main interrupt cause register for the chip.
Brett Russ05b308e2005-10-05 17:08:53 -04002860 *
2861 * LOCKING:
2862 * Inherited from caller.
2863 */
Mark Lord7368f912008-04-25 11:24:24 -04002864static int mv_host_intr(struct ata_host *host, u32 main_irq_cause)
Brett Russ20f733e2005-09-01 18:26:17 -04002865{
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05002866 struct mv_host_priv *hpriv = host->private_data;
Mark Lordeabd5eb2008-05-02 02:13:27 -04002867 void __iomem *mmio = hpriv->base, *hc_mmio;
Mark Lorda3718c12008-04-19 15:07:18 -04002868 unsigned int handled = 0, port;
Brett Russ20f733e2005-09-01 18:26:17 -04002869
Mark Lord2b748a02009-03-10 22:01:17 -04002870 /* If asserted, clear the "all ports" IRQ coalescing bit */
2871 if (main_irq_cause & ALL_PORTS_COAL_DONE)
Mark Lordcae5a292009-04-06 16:43:45 -04002872 writel(~ALL_PORTS_COAL_IRQ, mmio + IRQ_COAL_CAUSE);
Mark Lord2b748a02009-03-10 22:01:17 -04002873
Mark Lorda3718c12008-04-19 15:07:18 -04002874 for (port = 0; port < hpriv->n_ports; port++) {
Jeff Garzikcca39742006-08-24 03:19:22 -04002875 struct ata_port *ap = host->ports[port];
Mark Lordeabd5eb2008-05-02 02:13:27 -04002876 unsigned int p, shift, hardport, port_cause;
2877
Mark Lorda3718c12008-04-19 15:07:18 -04002878 MV_PORT_TO_SHIFT_AND_HARDPORT(port, shift, hardport);
Mark Lorda3718c12008-04-19 15:07:18 -04002879 /*
Mark Lordeabd5eb2008-05-02 02:13:27 -04002880 * Each hc within the host has its own hc_irq_cause register,
2881 * where the interrupting ports bits get ack'd.
Mark Lorda3718c12008-04-19 15:07:18 -04002882 */
Mark Lordeabd5eb2008-05-02 02:13:27 -04002883 if (hardport == 0) { /* first port on this hc ? */
2884 u32 hc_cause = (main_irq_cause >> shift) & HC0_IRQ_PEND;
2885 u32 port_mask, ack_irqs;
2886 /*
2887 * Skip this entire hc if nothing pending for any ports
2888 */
2889 if (!hc_cause) {
2890 port += MV_PORTS_PER_HC - 1;
2891 continue;
2892 }
2893 /*
2894 * We don't need/want to read the hc_irq_cause register,
2895 * because doing so hurts performance, and
2896 * main_irq_cause already gives us everything we need.
2897 *
2898 * But we do have to *write* to the hc_irq_cause to ack
2899 * the ports that we are handling this time through.
2900 *
2901 * This requires that we create a bitmap for those
2902 * ports which interrupted us, and use that bitmap
2903 * to ack (only) those ports via hc_irq_cause.
2904 */
2905 ack_irqs = 0;
Mark Lord2b748a02009-03-10 22:01:17 -04002906 if (hc_cause & PORTS_0_3_COAL_DONE)
2907 ack_irqs = HC_COAL_IRQ;
Mark Lordeabd5eb2008-05-02 02:13:27 -04002908 for (p = 0; p < MV_PORTS_PER_HC; ++p) {
2909 if ((port + p) >= hpriv->n_ports)
2910 break;
2911 port_mask = (DONE_IRQ | ERR_IRQ) << (p * 2);
2912 if (hc_cause & port_mask)
2913 ack_irqs |= (DMA_IRQ | DEV_IRQ) << p;
2914 }
Mark Lorda3718c12008-04-19 15:07:18 -04002915 hc_mmio = mv_hc_base_from_port(mmio, port);
Mark Lordcae5a292009-04-06 16:43:45 -04002916 writelfl(~ack_irqs, hc_mmio + HC_IRQ_CAUSE);
Mark Lorda3718c12008-04-19 15:07:18 -04002917 handled = 1;
2918 }
Mark Lorda9010322008-05-02 02:14:02 -04002919 /*
2920 * Handle interrupts signalled for this port:
2921 */
Mark Lordeabd5eb2008-05-02 02:13:27 -04002922 port_cause = (main_irq_cause >> shift) & (DONE_IRQ | ERR_IRQ);
Mark Lorda9010322008-05-02 02:14:02 -04002923 if (port_cause)
2924 mv_port_intr(ap, port_cause);
Brett Russ20f733e2005-09-01 18:26:17 -04002925 }
Mark Lorda3718c12008-04-19 15:07:18 -04002926 return handled;
Brett Russ20f733e2005-09-01 18:26:17 -04002927}
2928
Mark Lorda3718c12008-04-19 15:07:18 -04002929static int mv_pci_error(struct ata_host *host, void __iomem *mmio)
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002930{
Mark Lord02a121d2007-12-01 13:07:22 -05002931 struct mv_host_priv *hpriv = host->private_data;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002932 struct ata_port *ap;
2933 struct ata_queued_cmd *qc;
2934 struct ata_eh_info *ehi;
2935 unsigned int i, err_mask, printed = 0;
2936 u32 err_cause;
2937
Mark Lordcae5a292009-04-06 16:43:45 -04002938 err_cause = readl(mmio + hpriv->irq_cause_offset);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002939
Joe Perchesa44fec12011-04-15 15:51:58 -07002940 dev_err(host->dev, "PCI ERROR; PCI IRQ cause=0x%08x\n", err_cause);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002941
2942 DPRINTK("All regs @ PCI error\n");
2943 mv_dump_all_regs(mmio, -1, to_pci_dev(host->dev));
2944
Mark Lordcae5a292009-04-06 16:43:45 -04002945 writelfl(0, mmio + hpriv->irq_cause_offset);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002946
2947 for (i = 0; i < host->n_ports; i++) {
2948 ap = host->ports[i];
Tejun Heo936fd732007-08-06 18:36:23 +09002949 if (!ata_link_offline(&ap->link)) {
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002950 ehi = &ap->link.eh_info;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002951 ata_ehi_clear_desc(ehi);
2952 if (!printed++)
2953 ata_ehi_push_desc(ehi,
2954 "PCI err cause 0x%08x", err_cause);
2955 err_mask = AC_ERR_HOST_BUS;
Tejun Heocf480622008-01-24 00:05:14 +09002956 ehi->action = ATA_EH_RESET;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09002957 qc = ata_qc_from_tag(ap, ap->link.active_tag);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002958 if (qc)
2959 qc->err_mask |= err_mask;
2960 else
2961 ehi->err_mask |= err_mask;
2962
2963 ata_port_freeze(ap);
2964 }
2965 }
Mark Lorda3718c12008-04-19 15:07:18 -04002966 return 1; /* handled */
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04002967}
2968
Brett Russ05b308e2005-10-05 17:08:53 -04002969/**
Jeff Garzikc5d3e452007-07-11 18:30:50 -04002970 * mv_interrupt - Main interrupt event handler
Brett Russ05b308e2005-10-05 17:08:53 -04002971 * @irq: unused
2972 * @dev_instance: private data; in this case the host structure
Brett Russ05b308e2005-10-05 17:08:53 -04002973 *
2974 * Read the read only register to determine if any host
2975 * controllers have pending interrupts. If so, call lower level
2976 * routine to handle. Also check for PCI errors which are only
2977 * reported here.
2978 *
Jeff Garzik8b260242005-11-12 12:32:50 -05002979 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04002980 * This routine holds the host lock while processing pending
Brett Russ05b308e2005-10-05 17:08:53 -04002981 * interrupts.
2982 */
David Howells7d12e782006-10-05 14:55:46 +01002983static irqreturn_t mv_interrupt(int irq, void *dev_instance)
Brett Russ20f733e2005-09-01 18:26:17 -04002984{
Jeff Garzikcca39742006-08-24 03:19:22 -04002985 struct ata_host *host = dev_instance;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05002986 struct mv_host_priv *hpriv = host->private_data;
Mark Lorda3718c12008-04-19 15:07:18 -04002987 unsigned int handled = 0;
Mark Lord6d3c30e2009-01-21 10:31:29 -05002988 int using_msi = hpriv->hp_flags & MV_HP_FLAG_MSI;
Mark Lord96e2c4872008-05-17 13:38:00 -04002989 u32 main_irq_cause, pending_irqs;
Brett Russ20f733e2005-09-01 18:26:17 -04002990
Mark Lord646a4da2008-01-26 18:30:37 -05002991 spin_lock(&host->lock);
Mark Lord6d3c30e2009-01-21 10:31:29 -05002992
2993 /* for MSI: block new interrupts while in here */
2994 if (using_msi)
Mark Lord2b748a02009-03-10 22:01:17 -04002995 mv_write_main_irq_mask(0, hpriv);
Mark Lord6d3c30e2009-01-21 10:31:29 -05002996
Mark Lord7368f912008-04-25 11:24:24 -04002997 main_irq_cause = readl(hpriv->main_irq_cause_addr);
Mark Lord96e2c4872008-05-17 13:38:00 -04002998 pending_irqs = main_irq_cause & hpriv->main_irq_mask;
Mark Lord352fab72008-04-19 14:43:42 -04002999 /*
3000 * Deal with cases where we either have nothing pending, or have read
3001 * a bogus register value which can indicate HW removal or PCI fault.
Brett Russ20f733e2005-09-01 18:26:17 -04003002 */
Mark Lorda44253d2008-05-17 13:37:07 -04003003 if (pending_irqs && main_irq_cause != 0xffffffffU) {
Mark Lord1f398472008-05-27 17:54:48 -04003004 if (unlikely((pending_irqs & PCI_ERR) && !IS_SOC(hpriv)))
Mark Lorda3718c12008-04-19 15:07:18 -04003005 handled = mv_pci_error(host, hpriv->base);
3006 else
Mark Lorda44253d2008-05-17 13:37:07 -04003007 handled = mv_host_intr(host, pending_irqs);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003008 }
Mark Lord6d3c30e2009-01-21 10:31:29 -05003009
3010 /* for MSI: unmask; interrupt cause bits will retrigger now */
3011 if (using_msi)
Mark Lord2b748a02009-03-10 22:01:17 -04003012 mv_write_main_irq_mask(hpriv->main_irq_mask, hpriv);
Mark Lord6d3c30e2009-01-21 10:31:29 -05003013
Mark Lord9d51af72009-03-10 16:28:51 -04003014 spin_unlock(&host->lock);
3015
Brett Russ20f733e2005-09-01 18:26:17 -04003016 return IRQ_RETVAL(handled);
3017}
3018
Jeff Garzikc9d39132005-11-13 17:47:51 -05003019static unsigned int mv5_scr_offset(unsigned int sc_reg_in)
3020{
3021 unsigned int ofs;
3022
3023 switch (sc_reg_in) {
3024 case SCR_STATUS:
3025 case SCR_ERROR:
3026 case SCR_CONTROL:
3027 ofs = sc_reg_in * sizeof(u32);
3028 break;
3029 default:
3030 ofs = 0xffffffffU;
3031 break;
3032 }
3033 return ofs;
3034}
3035
Tejun Heo82ef04f2008-07-31 17:02:40 +09003036static int mv5_scr_read(struct ata_link *link, unsigned int sc_reg_in, u32 *val)
Jeff Garzikc9d39132005-11-13 17:47:51 -05003037{
Tejun Heo82ef04f2008-07-31 17:02:40 +09003038 struct mv_host_priv *hpriv = link->ap->host->private_data;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003039 void __iomem *mmio = hpriv->base;
Tejun Heo82ef04f2008-07-31 17:02:40 +09003040 void __iomem *addr = mv5_phy_base(mmio, link->ap->port_no);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003041 unsigned int ofs = mv5_scr_offset(sc_reg_in);
3042
Tejun Heoda3dbb12007-07-16 14:29:40 +09003043 if (ofs != 0xffffffffU) {
3044 *val = readl(addr + ofs);
3045 return 0;
3046 } else
3047 return -EINVAL;
Jeff Garzikc9d39132005-11-13 17:47:51 -05003048}
3049
Tejun Heo82ef04f2008-07-31 17:02:40 +09003050static int mv5_scr_write(struct ata_link *link, unsigned int sc_reg_in, u32 val)
Jeff Garzikc9d39132005-11-13 17:47:51 -05003051{
Tejun Heo82ef04f2008-07-31 17:02:40 +09003052 struct mv_host_priv *hpriv = link->ap->host->private_data;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003053 void __iomem *mmio = hpriv->base;
Tejun Heo82ef04f2008-07-31 17:02:40 +09003054 void __iomem *addr = mv5_phy_base(mmio, link->ap->port_no);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003055 unsigned int ofs = mv5_scr_offset(sc_reg_in);
3056
Tejun Heoda3dbb12007-07-16 14:29:40 +09003057 if (ofs != 0xffffffffU) {
Tejun Heo0d5ff562007-02-01 15:06:36 +09003058 writelfl(val, addr + ofs);
Tejun Heoda3dbb12007-07-16 14:29:40 +09003059 return 0;
3060 } else
3061 return -EINVAL;
Jeff Garzikc9d39132005-11-13 17:47:51 -05003062}
3063
Saeed Bishara7bb3c522008-01-30 11:50:45 -11003064static void mv5_reset_bus(struct ata_host *host, void __iomem *mmio)
Jeff Garzik522479f2005-11-12 22:14:02 -05003065{
Saeed Bishara7bb3c522008-01-30 11:50:45 -11003066 struct pci_dev *pdev = to_pci_dev(host->dev);
Jeff Garzik522479f2005-11-12 22:14:02 -05003067 int early_5080;
3068
Auke Kok44c10132007-06-08 15:46:36 -07003069 early_5080 = (pdev->device == 0x5080) && (pdev->revision == 0);
Jeff Garzik522479f2005-11-12 22:14:02 -05003070
3071 if (!early_5080) {
3072 u32 tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
3073 tmp |= (1 << 0);
3074 writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
3075 }
3076
Saeed Bishara7bb3c522008-01-30 11:50:45 -11003077 mv_reset_pci_bus(host, mmio);
Jeff Garzik522479f2005-11-12 22:14:02 -05003078}
3079
3080static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
3081{
Mark Lordcae5a292009-04-06 16:43:45 -04003082 writel(0x0fcfffff, mmio + FLASH_CTL);
Jeff Garzik522479f2005-11-12 22:14:02 -05003083}
3084
Jeff Garzik47c2b672005-11-12 21:13:17 -05003085static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003086 void __iomem *mmio)
3087{
Jeff Garzikc9d39132005-11-13 17:47:51 -05003088 void __iomem *phy_mmio = mv5_phy_base(mmio, idx);
3089 u32 tmp;
3090
3091 tmp = readl(phy_mmio + MV5_PHY_MODE);
3092
3093 hpriv->signal[idx].pre = tmp & 0x1800; /* bits 12:11 */
3094 hpriv->signal[idx].amps = tmp & 0xe0; /* bits 7:5 */
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003095}
3096
Jeff Garzik47c2b672005-11-12 21:13:17 -05003097static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003098{
Jeff Garzik522479f2005-11-12 22:14:02 -05003099 u32 tmp;
3100
Mark Lordcae5a292009-04-06 16:43:45 -04003101 writel(0, mmio + GPIO_PORT_CTL);
Jeff Garzik522479f2005-11-12 22:14:02 -05003102
3103 /* FIXME: handle MV_HP_ERRATA_50XXB2 errata */
3104
3105 tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
3106 tmp |= ~(1 << 0);
3107 writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003108}
3109
Jeff Garzik2a47ce02005-11-12 23:05:14 -05003110static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
3111 unsigned int port)
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003112{
Jeff Garzikc9d39132005-11-13 17:47:51 -05003113 void __iomem *phy_mmio = mv5_phy_base(mmio, port);
3114 const u32 mask = (1<<12) | (1<<11) | (1<<7) | (1<<6) | (1<<5);
3115 u32 tmp;
3116 int fix_apm_sq = (hpriv->hp_flags & MV_HP_ERRATA_50XXB0);
3117
3118 if (fix_apm_sq) {
Mark Lordcae5a292009-04-06 16:43:45 -04003119 tmp = readl(phy_mmio + MV5_LTMODE);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003120 tmp |= (1 << 19);
Mark Lordcae5a292009-04-06 16:43:45 -04003121 writel(tmp, phy_mmio + MV5_LTMODE);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003122
Mark Lordcae5a292009-04-06 16:43:45 -04003123 tmp = readl(phy_mmio + MV5_PHY_CTL);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003124 tmp &= ~0x3;
3125 tmp |= 0x1;
Mark Lordcae5a292009-04-06 16:43:45 -04003126 writel(tmp, phy_mmio + MV5_PHY_CTL);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003127 }
3128
3129 tmp = readl(phy_mmio + MV5_PHY_MODE);
3130 tmp &= ~mask;
3131 tmp |= hpriv->signal[port].pre;
3132 tmp |= hpriv->signal[port].amps;
3133 writel(tmp, phy_mmio + MV5_PHY_MODE);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003134}
3135
Jeff Garzikc9d39132005-11-13 17:47:51 -05003136
3137#undef ZERO
3138#define ZERO(reg) writel(0, port_mmio + (reg))
3139static void mv5_reset_hc_port(struct mv_host_priv *hpriv, void __iomem *mmio,
3140 unsigned int port)
Jeff Garzik47c2b672005-11-12 21:13:17 -05003141{
Jeff Garzikc9d39132005-11-13 17:47:51 -05003142 void __iomem *port_mmio = mv_port_base(mmio, port);
3143
Mark Lorde12bef52008-03-31 19:33:56 -04003144 mv_reset_channel(hpriv, mmio, port);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003145
3146 ZERO(0x028); /* command */
Mark Lordcae5a292009-04-06 16:43:45 -04003147 writel(0x11f, port_mmio + EDMA_CFG);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003148 ZERO(0x004); /* timer */
3149 ZERO(0x008); /* irq err cause */
3150 ZERO(0x00c); /* irq err mask */
3151 ZERO(0x010); /* rq bah */
3152 ZERO(0x014); /* rq inp */
3153 ZERO(0x018); /* rq outp */
3154 ZERO(0x01c); /* respq bah */
3155 ZERO(0x024); /* respq outp */
3156 ZERO(0x020); /* respq inp */
3157 ZERO(0x02c); /* test control */
Mark Lordcae5a292009-04-06 16:43:45 -04003158 writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
Jeff Garzikc9d39132005-11-13 17:47:51 -05003159}
3160#undef ZERO
3161
3162#define ZERO(reg) writel(0, hc_mmio + (reg))
3163static void mv5_reset_one_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
3164 unsigned int hc)
3165{
3166 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
3167 u32 tmp;
3168
3169 ZERO(0x00c);
3170 ZERO(0x010);
3171 ZERO(0x014);
3172 ZERO(0x018);
3173
3174 tmp = readl(hc_mmio + 0x20);
3175 tmp &= 0x1c1c1c1c;
3176 tmp |= 0x03030303;
3177 writel(tmp, hc_mmio + 0x20);
3178}
3179#undef ZERO
3180
3181static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
3182 unsigned int n_hc)
3183{
3184 unsigned int hc, port;
3185
3186 for (hc = 0; hc < n_hc; hc++) {
3187 for (port = 0; port < MV_PORTS_PER_HC; port++)
3188 mv5_reset_hc_port(hpriv, mmio,
3189 (hc * MV_PORTS_PER_HC) + port);
3190
3191 mv5_reset_one_hc(hpriv, mmio, hc);
3192 }
3193
3194 return 0;
Jeff Garzik47c2b672005-11-12 21:13:17 -05003195}
3196
Jeff Garzik101ffae2005-11-12 22:17:49 -05003197#undef ZERO
3198#define ZERO(reg) writel(0, mmio + (reg))
Saeed Bishara7bb3c522008-01-30 11:50:45 -11003199static void mv_reset_pci_bus(struct ata_host *host, void __iomem *mmio)
Jeff Garzik101ffae2005-11-12 22:17:49 -05003200{
Mark Lord02a121d2007-12-01 13:07:22 -05003201 struct mv_host_priv *hpriv = host->private_data;
Jeff Garzik101ffae2005-11-12 22:17:49 -05003202 u32 tmp;
3203
Mark Lordcae5a292009-04-06 16:43:45 -04003204 tmp = readl(mmio + MV_PCI_MODE);
Jeff Garzik101ffae2005-11-12 22:17:49 -05003205 tmp &= 0xff00ffff;
Mark Lordcae5a292009-04-06 16:43:45 -04003206 writel(tmp, mmio + MV_PCI_MODE);
Jeff Garzik101ffae2005-11-12 22:17:49 -05003207
3208 ZERO(MV_PCI_DISC_TIMER);
3209 ZERO(MV_PCI_MSI_TRIGGER);
Mark Lordcae5a292009-04-06 16:43:45 -04003210 writel(0x000100ff, mmio + MV_PCI_XBAR_TMOUT);
Jeff Garzik101ffae2005-11-12 22:17:49 -05003211 ZERO(MV_PCI_SERR_MASK);
Mark Lordcae5a292009-04-06 16:43:45 -04003212 ZERO(hpriv->irq_cause_offset);
3213 ZERO(hpriv->irq_mask_offset);
Jeff Garzik101ffae2005-11-12 22:17:49 -05003214 ZERO(MV_PCI_ERR_LOW_ADDRESS);
3215 ZERO(MV_PCI_ERR_HIGH_ADDRESS);
3216 ZERO(MV_PCI_ERR_ATTRIBUTE);
3217 ZERO(MV_PCI_ERR_COMMAND);
3218}
3219#undef ZERO
3220
3221static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
3222{
3223 u32 tmp;
3224
3225 mv5_reset_flash(hpriv, mmio);
3226
Mark Lordcae5a292009-04-06 16:43:45 -04003227 tmp = readl(mmio + GPIO_PORT_CTL);
Jeff Garzik101ffae2005-11-12 22:17:49 -05003228 tmp &= 0x3;
3229 tmp |= (1 << 5) | (1 << 6);
Mark Lordcae5a292009-04-06 16:43:45 -04003230 writel(tmp, mmio + GPIO_PORT_CTL);
Jeff Garzik101ffae2005-11-12 22:17:49 -05003231}
3232
3233/**
3234 * mv6_reset_hc - Perform the 6xxx global soft reset
3235 * @mmio: base address of the HBA
3236 *
3237 * This routine only applies to 6xxx parts.
3238 *
3239 * LOCKING:
3240 * Inherited from caller.
3241 */
Jeff Garzikc9d39132005-11-13 17:47:51 -05003242static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
3243 unsigned int n_hc)
Jeff Garzik101ffae2005-11-12 22:17:49 -05003244{
Mark Lordcae5a292009-04-06 16:43:45 -04003245 void __iomem *reg = mmio + PCI_MAIN_CMD_STS;
Jeff Garzik101ffae2005-11-12 22:17:49 -05003246 int i, rc = 0;
3247 u32 t;
3248
3249 /* Following procedure defined in PCI "main command and status
3250 * register" table.
3251 */
3252 t = readl(reg);
3253 writel(t | STOP_PCI_MASTER, reg);
3254
3255 for (i = 0; i < 1000; i++) {
3256 udelay(1);
3257 t = readl(reg);
Jeff Garzik2dcb4072007-10-19 06:42:56 -04003258 if (PCI_MASTER_EMPTY & t)
Jeff Garzik101ffae2005-11-12 22:17:49 -05003259 break;
Jeff Garzik101ffae2005-11-12 22:17:49 -05003260 }
3261 if (!(PCI_MASTER_EMPTY & t)) {
3262 printk(KERN_ERR DRV_NAME ": PCI master won't flush\n");
3263 rc = 1;
3264 goto done;
3265 }
3266
3267 /* set reset */
3268 i = 5;
3269 do {
3270 writel(t | GLOB_SFT_RST, reg);
3271 t = readl(reg);
3272 udelay(1);
3273 } while (!(GLOB_SFT_RST & t) && (i-- > 0));
3274
3275 if (!(GLOB_SFT_RST & t)) {
3276 printk(KERN_ERR DRV_NAME ": can't set global reset\n");
3277 rc = 1;
3278 goto done;
3279 }
3280
3281 /* clear reset and *reenable the PCI master* (not mentioned in spec) */
3282 i = 5;
3283 do {
3284 writel(t & ~(GLOB_SFT_RST | STOP_PCI_MASTER), reg);
3285 t = readl(reg);
3286 udelay(1);
3287 } while ((GLOB_SFT_RST & t) && (i-- > 0));
3288
3289 if (GLOB_SFT_RST & t) {
3290 printk(KERN_ERR DRV_NAME ": can't clear global reset\n");
3291 rc = 1;
3292 }
3293done:
3294 return rc;
3295}
3296
Jeff Garzik47c2b672005-11-12 21:13:17 -05003297static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003298 void __iomem *mmio)
3299{
3300 void __iomem *port_mmio;
3301 u32 tmp;
3302
Mark Lordcae5a292009-04-06 16:43:45 -04003303 tmp = readl(mmio + RESET_CFG);
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003304 if ((tmp & (1 << 0)) == 0) {
Jeff Garzik47c2b672005-11-12 21:13:17 -05003305 hpriv->signal[idx].amps = 0x7 << 8;
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003306 hpriv->signal[idx].pre = 0x1 << 5;
3307 return;
3308 }
3309
3310 port_mmio = mv_port_base(mmio, idx);
3311 tmp = readl(port_mmio + PHY_MODE2);
3312
3313 hpriv->signal[idx].amps = tmp & 0x700; /* bits 10:8 */
3314 hpriv->signal[idx].pre = tmp & 0xe0; /* bits 7:5 */
3315}
3316
Jeff Garzik47c2b672005-11-12 21:13:17 -05003317static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003318{
Mark Lordcae5a292009-04-06 16:43:45 -04003319 writel(0x00000060, mmio + GPIO_PORT_CTL);
Jeff Garzikba3fe8f2005-11-12 19:08:48 -05003320}
3321
Jeff Garzikc9d39132005-11-13 17:47:51 -05003322static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
Jeff Garzik2a47ce02005-11-12 23:05:14 -05003323 unsigned int port)
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003324{
Jeff Garzikc9d39132005-11-13 17:47:51 -05003325 void __iomem *port_mmio = mv_port_base(mmio, port);
3326
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003327 u32 hp_flags = hpriv->hp_flags;
Jeff Garzik47c2b672005-11-12 21:13:17 -05003328 int fix_phy_mode2 =
3329 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003330 int fix_phy_mode4 =
Jeff Garzik47c2b672005-11-12 21:13:17 -05003331 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
Mark Lord8c30a8b2008-05-27 17:56:31 -04003332 u32 m2, m3;
Jeff Garzik47c2b672005-11-12 21:13:17 -05003333
3334 if (fix_phy_mode2) {
3335 m2 = readl(port_mmio + PHY_MODE2);
3336 m2 &= ~(1 << 16);
3337 m2 |= (1 << 31);
3338 writel(m2, port_mmio + PHY_MODE2);
3339
3340 udelay(200);
3341
3342 m2 = readl(port_mmio + PHY_MODE2);
3343 m2 &= ~((1 << 16) | (1 << 31));
3344 writel(m2, port_mmio + PHY_MODE2);
3345
3346 udelay(200);
3347 }
3348
Mark Lord8c30a8b2008-05-27 17:56:31 -04003349 /*
3350 * Gen-II/IIe PHY_MODE3 errata RM#2:
3351 * Achieves better receiver noise performance than the h/w default:
3352 */
3353 m3 = readl(port_mmio + PHY_MODE3);
3354 m3 = (m3 & 0x1f) | (0x5555601 << 5);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003355
Mark Lord0388a8c2008-05-28 13:41:52 -04003356 /* Guideline 88F5182 (GL# SATA-S11) */
3357 if (IS_SOC(hpriv))
3358 m3 &= ~0x1c;
3359
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003360 if (fix_phy_mode4) {
Mark Lordba069e32008-05-31 16:46:34 -04003361 u32 m4 = readl(port_mmio + PHY_MODE4);
3362 /*
3363 * Enforce reserved-bit restrictions on GenIIe devices only.
3364 * For earlier chipsets, force only the internal config field
3365 * (workaround for errata FEr SATA#10 part 1).
3366 */
Mark Lord8c30a8b2008-05-27 17:56:31 -04003367 if (IS_GEN_IIE(hpriv))
Mark Lordba069e32008-05-31 16:46:34 -04003368 m4 = (m4 & ~PHY_MODE4_RSVD_ZEROS) | PHY_MODE4_RSVD_ONES;
3369 else
3370 m4 = (m4 & ~PHY_MODE4_CFG_MASK) | PHY_MODE4_CFG_VALUE;
Mark Lord8c30a8b2008-05-27 17:56:31 -04003371 writel(m4, port_mmio + PHY_MODE4);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003372 }
Mark Lordb406c7a2008-05-28 12:01:12 -04003373 /*
3374 * Workaround for 60x1-B2 errata SATA#13:
3375 * Any write to PHY_MODE4 (above) may corrupt PHY_MODE3,
3376 * so we must always rewrite PHY_MODE3 after PHY_MODE4.
Mark Lordba684602009-04-06 15:25:39 -04003377 * Or ensure we use writelfl() when writing PHY_MODE4.
Mark Lordb406c7a2008-05-28 12:01:12 -04003378 */
3379 writel(m3, port_mmio + PHY_MODE3);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003380
3381 /* Revert values of pre-emphasis and signal amps to the saved ones */
3382 m2 = readl(port_mmio + PHY_MODE2);
3383
3384 m2 &= ~MV_M2_PREAMP_MASK;
Jeff Garzik2a47ce02005-11-12 23:05:14 -05003385 m2 |= hpriv->signal[port].amps;
3386 m2 |= hpriv->signal[port].pre;
Jeff Garzik47c2b672005-11-12 21:13:17 -05003387 m2 &= ~(1 << 16);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003388
Jeff Garzike4e7b892006-01-31 12:18:41 -05003389 /* according to mvSata 3.6.1, some IIE values are fixed */
3390 if (IS_GEN_IIE(hpriv)) {
3391 m2 &= ~0xC30FF01F;
3392 m2 |= 0x0000900F;
3393 }
3394
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003395 writel(m2, port_mmio + PHY_MODE2);
3396}
3397
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003398/* TODO: use the generic LED interface to configure the SATA Presence */
3399/* & Acitivy LEDs on the board */
3400static void mv_soc_enable_leds(struct mv_host_priv *hpriv,
3401 void __iomem *mmio)
3402{
3403 return;
3404}
3405
3406static void mv_soc_read_preamp(struct mv_host_priv *hpriv, int idx,
3407 void __iomem *mmio)
3408{
3409 void __iomem *port_mmio;
3410 u32 tmp;
3411
3412 port_mmio = mv_port_base(mmio, idx);
3413 tmp = readl(port_mmio + PHY_MODE2);
3414
3415 hpriv->signal[idx].amps = tmp & 0x700; /* bits 10:8 */
3416 hpriv->signal[idx].pre = tmp & 0xe0; /* bits 7:5 */
3417}
3418
3419#undef ZERO
3420#define ZERO(reg) writel(0, port_mmio + (reg))
3421static void mv_soc_reset_hc_port(struct mv_host_priv *hpriv,
3422 void __iomem *mmio, unsigned int port)
3423{
3424 void __iomem *port_mmio = mv_port_base(mmio, port);
3425
Mark Lorde12bef52008-03-31 19:33:56 -04003426 mv_reset_channel(hpriv, mmio, port);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003427
3428 ZERO(0x028); /* command */
Mark Lordcae5a292009-04-06 16:43:45 -04003429 writel(0x101f, port_mmio + EDMA_CFG);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003430 ZERO(0x004); /* timer */
3431 ZERO(0x008); /* irq err cause */
3432 ZERO(0x00c); /* irq err mask */
3433 ZERO(0x010); /* rq bah */
3434 ZERO(0x014); /* rq inp */
3435 ZERO(0x018); /* rq outp */
3436 ZERO(0x01c); /* respq bah */
3437 ZERO(0x024); /* respq outp */
3438 ZERO(0x020); /* respq inp */
3439 ZERO(0x02c); /* test control */
Saeed Bisharad7b0c142009-12-06 18:26:17 +02003440 writel(0x800, port_mmio + EDMA_IORDY_TMOUT);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003441}
3442
3443#undef ZERO
3444
3445#define ZERO(reg) writel(0, hc_mmio + (reg))
3446static void mv_soc_reset_one_hc(struct mv_host_priv *hpriv,
3447 void __iomem *mmio)
3448{
3449 void __iomem *hc_mmio = mv_hc_base(mmio, 0);
3450
3451 ZERO(0x00c);
3452 ZERO(0x010);
3453 ZERO(0x014);
3454
3455}
3456
3457#undef ZERO
3458
3459static int mv_soc_reset_hc(struct mv_host_priv *hpriv,
3460 void __iomem *mmio, unsigned int n_hc)
3461{
3462 unsigned int port;
3463
3464 for (port = 0; port < hpriv->n_ports; port++)
3465 mv_soc_reset_hc_port(hpriv, mmio, port);
3466
3467 mv_soc_reset_one_hc(hpriv, mmio);
3468
3469 return 0;
3470}
3471
3472static void mv_soc_reset_flash(struct mv_host_priv *hpriv,
3473 void __iomem *mmio)
3474{
3475 return;
3476}
3477
3478static void mv_soc_reset_bus(struct ata_host *host, void __iomem *mmio)
3479{
3480 return;
3481}
3482
Martin Michlmayr29b7e432009-05-04 20:58:50 +02003483static void mv_soc_65n_phy_errata(struct mv_host_priv *hpriv,
3484 void __iomem *mmio, unsigned int port)
3485{
3486 void __iomem *port_mmio = mv_port_base(mmio, port);
3487 u32 reg;
3488
3489 reg = readl(port_mmio + PHY_MODE3);
3490 reg &= ~(0x3 << 27); /* SELMUPF (bits 28:27) to 1 */
3491 reg |= (0x1 << 27);
3492 reg &= ~(0x3 << 29); /* SELMUPI (bits 30:29) to 1 */
3493 reg |= (0x1 << 29);
3494 writel(reg, port_mmio + PHY_MODE3);
3495
3496 reg = readl(port_mmio + PHY_MODE4);
3497 reg &= ~0x1; /* SATU_OD8 (bit 0) to 0, reserved bit 16 must be set */
3498 reg |= (0x1 << 16);
3499 writel(reg, port_mmio + PHY_MODE4);
3500
3501 reg = readl(port_mmio + PHY_MODE9_GEN2);
3502 reg &= ~0xf; /* TXAMP[3:0] (bits 3:0) to 8 */
3503 reg |= 0x8;
3504 reg &= ~(0x1 << 14); /* TXAMP[4] (bit 14) to 0 */
3505 writel(reg, port_mmio + PHY_MODE9_GEN2);
3506
3507 reg = readl(port_mmio + PHY_MODE9_GEN1);
3508 reg &= ~0xf; /* TXAMP[3:0] (bits 3:0) to 8 */
3509 reg |= 0x8;
3510 reg &= ~(0x1 << 14); /* TXAMP[4] (bit 14) to 0 */
3511 writel(reg, port_mmio + PHY_MODE9_GEN1);
3512}
3513
3514/**
3515 * soc_is_65 - check if the soc is 65 nano device
3516 *
3517 * Detect the type of the SoC, this is done by reading the PHYCFG_OFS
3518 * register, this register should contain non-zero value and it exists only
3519 * in the 65 nano devices, when reading it from older devices we get 0.
3520 */
3521static bool soc_is_65n(struct mv_host_priv *hpriv)
3522{
3523 void __iomem *port0_mmio = mv_port_base(hpriv->base, 0);
3524
3525 if (readl(port0_mmio + PHYCFG_OFS))
3526 return true;
3527 return false;
3528}
3529
Mark Lord8e7decd2008-05-02 02:07:51 -04003530static void mv_setup_ifcfg(void __iomem *port_mmio, int want_gen2i)
Mark Lordb67a1062008-03-31 19:35:13 -04003531{
Mark Lordcae5a292009-04-06 16:43:45 -04003532 u32 ifcfg = readl(port_mmio + SATA_IFCFG);
Mark Lordb67a1062008-03-31 19:35:13 -04003533
Mark Lord8e7decd2008-05-02 02:07:51 -04003534 ifcfg = (ifcfg & 0xf7f) | 0x9b1000; /* from chip spec */
Mark Lordb67a1062008-03-31 19:35:13 -04003535 if (want_gen2i)
Mark Lord8e7decd2008-05-02 02:07:51 -04003536 ifcfg |= (1 << 7); /* enable gen2i speed */
Mark Lordcae5a292009-04-06 16:43:45 -04003537 writelfl(ifcfg, port_mmio + SATA_IFCFG);
Mark Lordb67a1062008-03-31 19:35:13 -04003538}
3539
Mark Lorde12bef52008-03-31 19:33:56 -04003540static void mv_reset_channel(struct mv_host_priv *hpriv, void __iomem *mmio,
Jeff Garzikc9d39132005-11-13 17:47:51 -05003541 unsigned int port_no)
Brett Russ20f733e2005-09-01 18:26:17 -04003542{
Jeff Garzikc9d39132005-11-13 17:47:51 -05003543 void __iomem *port_mmio = mv_port_base(mmio, port_no);
Brett Russ20f733e2005-09-01 18:26:17 -04003544
Mark Lord8e7decd2008-05-02 02:07:51 -04003545 /*
3546 * The datasheet warns against setting EDMA_RESET when EDMA is active
3547 * (but doesn't say what the problem might be). So we first try
3548 * to disable the EDMA engine before doing the EDMA_RESET operation.
3549 */
Mark Lord0d8be5c2008-04-16 14:56:12 -04003550 mv_stop_edma_engine(port_mmio);
Mark Lordcae5a292009-04-06 16:43:45 -04003551 writelfl(EDMA_RESET, port_mmio + EDMA_CMD);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003552
Mark Lordb67a1062008-03-31 19:35:13 -04003553 if (!IS_GEN_I(hpriv)) {
Mark Lord8e7decd2008-05-02 02:07:51 -04003554 /* Enable 3.0gb/s link speed: this survives EDMA_RESET */
3555 mv_setup_ifcfg(port_mmio, 1);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003556 }
Mark Lordb67a1062008-03-31 19:35:13 -04003557 /*
Mark Lord8e7decd2008-05-02 02:07:51 -04003558 * Strobing EDMA_RESET here causes a hard reset of the SATA transport,
Mark Lordb67a1062008-03-31 19:35:13 -04003559 * link, and physical layers. It resets all SATA interface registers
Mark Lordcae5a292009-04-06 16:43:45 -04003560 * (except for SATA_IFCFG), and issues a COMRESET to the dev.
Brett Russ20f733e2005-09-01 18:26:17 -04003561 */
Mark Lordcae5a292009-04-06 16:43:45 -04003562 writelfl(EDMA_RESET, port_mmio + EDMA_CMD);
Mark Lordb67a1062008-03-31 19:35:13 -04003563 udelay(25); /* allow reset propagation */
Mark Lordcae5a292009-04-06 16:43:45 -04003564 writelfl(0, port_mmio + EDMA_CMD);
Brett Russ20f733e2005-09-01 18:26:17 -04003565
Jeff Garzikc9d39132005-11-13 17:47:51 -05003566 hpriv->ops->phy_errata(hpriv, mmio, port_no);
3567
Jeff Garzikee9ccdf2007-07-12 15:51:22 -04003568 if (IS_GEN_I(hpriv))
Jeff Garzikc9d39132005-11-13 17:47:51 -05003569 mdelay(1);
3570}
3571
Mark Lorde49856d2008-04-16 14:59:07 -04003572static void mv_pmp_select(struct ata_port *ap, int pmp)
Jeff Garzikc9d39132005-11-13 17:47:51 -05003573{
Mark Lorde49856d2008-04-16 14:59:07 -04003574 if (sata_pmp_supported(ap)) {
3575 void __iomem *port_mmio = mv_ap_base(ap);
Mark Lordcae5a292009-04-06 16:43:45 -04003576 u32 reg = readl(port_mmio + SATA_IFCTL);
Mark Lorde49856d2008-04-16 14:59:07 -04003577 int old = reg & 0xf;
Jeff Garzikc9d39132005-11-13 17:47:51 -05003578
Mark Lorde49856d2008-04-16 14:59:07 -04003579 if (old != pmp) {
3580 reg = (reg & ~0xf) | pmp;
Mark Lordcae5a292009-04-06 16:43:45 -04003581 writelfl(reg, port_mmio + SATA_IFCTL);
Mark Lorde49856d2008-04-16 14:59:07 -04003582 }
Tejun Heoda3dbb12007-07-16 14:29:40 +09003583 }
Brett Russ20f733e2005-09-01 18:26:17 -04003584}
3585
Mark Lorde49856d2008-04-16 14:59:07 -04003586static int mv_pmp_hardreset(struct ata_link *link, unsigned int *class,
3587 unsigned long deadline)
Jeff Garzik22374672005-11-17 10:59:48 -05003588{
Mark Lorde49856d2008-04-16 14:59:07 -04003589 mv_pmp_select(link->ap, sata_srst_pmp(link));
3590 return sata_std_hardreset(link, class, deadline);
3591}
Jeff Garzik0ea9e172007-07-13 17:06:45 -04003592
Mark Lorde49856d2008-04-16 14:59:07 -04003593static int mv_softreset(struct ata_link *link, unsigned int *class,
3594 unsigned long deadline)
3595{
3596 mv_pmp_select(link->ap, sata_srst_pmp(link));
3597 return ata_sff_softreset(link, class, deadline);
Jeff Garzik22374672005-11-17 10:59:48 -05003598}
3599
Tejun Heocc0680a2007-08-06 18:36:23 +09003600static int mv_hardreset(struct ata_link *link, unsigned int *class,
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003601 unsigned long deadline)
3602{
Tejun Heocc0680a2007-08-06 18:36:23 +09003603 struct ata_port *ap = link->ap;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003604 struct mv_host_priv *hpriv = ap->host->private_data;
Mark Lordb5624682008-03-31 19:34:40 -04003605 struct mv_port_priv *pp = ap->private_data;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003606 void __iomem *mmio = hpriv->base;
Mark Lord0d8be5c2008-04-16 14:56:12 -04003607 int rc, attempts = 0, extra = 0;
3608 u32 sstatus;
3609 bool online;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003610
Mark Lorde12bef52008-03-31 19:33:56 -04003611 mv_reset_channel(hpriv, mmio, ap->port_no);
Mark Lordb5624682008-03-31 19:34:40 -04003612 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
Mark Lordd16ab3f2009-02-25 15:17:43 -05003613 pp->pp_flags &=
3614 ~(MV_PP_FLAG_FBS_EN | MV_PP_FLAG_NCQ_EN | MV_PP_FLAG_FAKE_ATA_BUSY);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003615
Mark Lord0d8be5c2008-04-16 14:56:12 -04003616 /* Workaround for errata FEr SATA#10 (part 2) */
3617 do {
Mark Lord17c5aab2008-04-16 14:56:51 -04003618 const unsigned long *timing =
3619 sata_ehc_deb_timing(&link->eh_context);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003620
Mark Lord17c5aab2008-04-16 14:56:51 -04003621 rc = sata_link_hardreset(link, timing, deadline + extra,
3622 &online, NULL);
Mark Lord9dcffd92008-05-14 09:18:12 -04003623 rc = online ? -EAGAIN : rc;
Mark Lord17c5aab2008-04-16 14:56:51 -04003624 if (rc)
Mark Lord0d8be5c2008-04-16 14:56:12 -04003625 return rc;
Mark Lord0d8be5c2008-04-16 14:56:12 -04003626 sata_scr_read(link, SCR_STATUS, &sstatus);
3627 if (!IS_GEN_I(hpriv) && ++attempts >= 5 && sstatus == 0x121) {
3628 /* Force 1.5gb/s link speed and try again */
Mark Lord8e7decd2008-05-02 02:07:51 -04003629 mv_setup_ifcfg(mv_ap_base(ap), 0);
Mark Lord0d8be5c2008-04-16 14:56:12 -04003630 if (time_after(jiffies + HZ, deadline))
3631 extra = HZ; /* only extend it once, max */
3632 }
3633 } while (sstatus != 0x0 && sstatus != 0x113 && sstatus != 0x123);
Mark Lord08da1752009-02-25 15:13:03 -05003634 mv_save_cached_regs(ap);
Mark Lord66e57a22009-01-30 18:52:58 -05003635 mv_edma_cfg(ap, 0, 0);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003636
Mark Lord17c5aab2008-04-16 14:56:51 -04003637 return rc;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003638}
3639
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003640static void mv_eh_freeze(struct ata_port *ap)
Brett Russ20f733e2005-09-01 18:26:17 -04003641{
Mark Lord1cfd19a2008-04-19 15:05:50 -04003642 mv_stop_edma(ap);
Mark Lordc4de5732008-05-17 13:35:21 -04003643 mv_enable_port_irqs(ap, 0);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003644}
3645
3646static void mv_eh_thaw(struct ata_port *ap)
3647{
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003648 struct mv_host_priv *hpriv = ap->host->private_data;
Mark Lordc4de5732008-05-17 13:35:21 -04003649 unsigned int port = ap->port_no;
3650 unsigned int hardport = mv_hardport_from_port(port);
Mark Lord1cfd19a2008-04-19 15:05:50 -04003651 void __iomem *hc_mmio = mv_hc_base_from_port(hpriv->base, port);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003652 void __iomem *port_mmio = mv_ap_base(ap);
Mark Lordc4de5732008-05-17 13:35:21 -04003653 u32 hc_irq_cause;
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003654
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003655 /* clear EDMA errors on this port */
Mark Lordcae5a292009-04-06 16:43:45 -04003656 writel(0, port_mmio + EDMA_ERR_IRQ_CAUSE);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003657
3658 /* clear pending irq events */
Mark Lordcae6edc2009-01-19 18:05:42 -05003659 hc_irq_cause = ~((DEV_IRQ | DMA_IRQ) << hardport);
Mark Lordcae5a292009-04-06 16:43:45 -04003660 writelfl(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE);
Jeff Garzikbdd4ddd2007-07-12 14:34:26 -04003661
Mark Lord88e675e2008-05-17 13:36:30 -04003662 mv_enable_port_irqs(ap, ERR_IRQ);
Brett Russ31961942005-09-30 01:36:00 -04003663}
3664
Brett Russ05b308e2005-10-05 17:08:53 -04003665/**
3666 * mv_port_init - Perform some early initialization on a single port.
3667 * @port: libata data structure storing shadow register addresses
3668 * @port_mmio: base address of the port
3669 *
3670 * Initialize shadow register mmio addresses, clear outstanding
3671 * interrupts on the port, and unmask interrupts for the future
3672 * start of the port.
3673 *
3674 * LOCKING:
3675 * Inherited from caller.
3676 */
Brett Russ31961942005-09-30 01:36:00 -04003677static void mv_port_init(struct ata_ioports *port, void __iomem *port_mmio)
3678{
Mark Lordcae5a292009-04-06 16:43:45 -04003679 void __iomem *serr, *shd_base = port_mmio + SHD_BLK;
Brett Russ31961942005-09-30 01:36:00 -04003680
Jeff Garzik8b260242005-11-12 12:32:50 -05003681 /* PIO related setup
Brett Russ31961942005-09-30 01:36:00 -04003682 */
3683 port->data_addr = shd_base + (sizeof(u32) * ATA_REG_DATA);
Jeff Garzik8b260242005-11-12 12:32:50 -05003684 port->error_addr =
Brett Russ31961942005-09-30 01:36:00 -04003685 port->feature_addr = shd_base + (sizeof(u32) * ATA_REG_ERR);
3686 port->nsect_addr = shd_base + (sizeof(u32) * ATA_REG_NSECT);
3687 port->lbal_addr = shd_base + (sizeof(u32) * ATA_REG_LBAL);
3688 port->lbam_addr = shd_base + (sizeof(u32) * ATA_REG_LBAM);
3689 port->lbah_addr = shd_base + (sizeof(u32) * ATA_REG_LBAH);
3690 port->device_addr = shd_base + (sizeof(u32) * ATA_REG_DEVICE);
Jeff Garzik8b260242005-11-12 12:32:50 -05003691 port->status_addr =
Brett Russ31961942005-09-30 01:36:00 -04003692 port->command_addr = shd_base + (sizeof(u32) * ATA_REG_STATUS);
3693 /* special case: control/altstatus doesn't have ATA_REG_ address */
Mark Lordcae5a292009-04-06 16:43:45 -04003694 port->altstatus_addr = port->ctl_addr = shd_base + SHD_CTL_AST;
Brett Russ31961942005-09-30 01:36:00 -04003695
Brett Russ31961942005-09-30 01:36:00 -04003696 /* Clear any currently outstanding port interrupt conditions */
Mark Lordcae5a292009-04-06 16:43:45 -04003697 serr = port_mmio + mv_scr_offset(SCR_ERROR);
3698 writelfl(readl(serr), serr);
3699 writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE);
Brett Russ31961942005-09-30 01:36:00 -04003700
Mark Lord646a4da2008-01-26 18:30:37 -05003701 /* unmask all non-transient EDMA error interrupts */
Mark Lordcae5a292009-04-06 16:43:45 -04003702 writelfl(~EDMA_ERR_IRQ_TRANSIENT, port_mmio + EDMA_ERR_IRQ_MASK);
Brett Russ20f733e2005-09-01 18:26:17 -04003703
Jeff Garzik8b260242005-11-12 12:32:50 -05003704 VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n",
Mark Lordcae5a292009-04-06 16:43:45 -04003705 readl(port_mmio + EDMA_CFG),
3706 readl(port_mmio + EDMA_ERR_IRQ_CAUSE),
3707 readl(port_mmio + EDMA_ERR_IRQ_MASK));
Brett Russ20f733e2005-09-01 18:26:17 -04003708}
3709
Mark Lord616d4a92008-05-02 02:08:32 -04003710static unsigned int mv_in_pcix_mode(struct ata_host *host)
3711{
3712 struct mv_host_priv *hpriv = host->private_data;
3713 void __iomem *mmio = hpriv->base;
3714 u32 reg;
3715
Mark Lord1f398472008-05-27 17:54:48 -04003716 if (IS_SOC(hpriv) || !IS_PCIE(hpriv))
Mark Lord616d4a92008-05-02 02:08:32 -04003717 return 0; /* not PCI-X capable */
Mark Lordcae5a292009-04-06 16:43:45 -04003718 reg = readl(mmio + MV_PCI_MODE);
Mark Lord616d4a92008-05-02 02:08:32 -04003719 if ((reg & MV_PCI_MODE_MASK) == 0)
3720 return 0; /* conventional PCI mode */
3721 return 1; /* chip is in PCI-X mode */
3722}
3723
3724static int mv_pci_cut_through_okay(struct ata_host *host)
3725{
3726 struct mv_host_priv *hpriv = host->private_data;
3727 void __iomem *mmio = hpriv->base;
3728 u32 reg;
3729
3730 if (!mv_in_pcix_mode(host)) {
Mark Lordcae5a292009-04-06 16:43:45 -04003731 reg = readl(mmio + MV_PCI_COMMAND);
3732 if (reg & MV_PCI_COMMAND_MRDTRIG)
Mark Lord616d4a92008-05-02 02:08:32 -04003733 return 0; /* not okay */
3734 }
3735 return 1; /* okay */
3736}
3737
Mark Lord65ad7fef2009-04-06 15:24:14 -04003738static void mv_60x1b2_errata_pci7(struct ata_host *host)
3739{
3740 struct mv_host_priv *hpriv = host->private_data;
3741 void __iomem *mmio = hpriv->base;
3742
3743 /* workaround for 60x1-B2 errata PCI#7 */
3744 if (mv_in_pcix_mode(host)) {
Mark Lordcae5a292009-04-06 16:43:45 -04003745 u32 reg = readl(mmio + MV_PCI_COMMAND);
3746 writelfl(reg & ~MV_PCI_COMMAND_MWRCOM, mmio + MV_PCI_COMMAND);
Mark Lord65ad7fef2009-04-06 15:24:14 -04003747 }
3748}
3749
Tejun Heo4447d352007-04-17 23:44:08 +09003750static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003751{
Tejun Heo4447d352007-04-17 23:44:08 +09003752 struct pci_dev *pdev = to_pci_dev(host->dev);
3753 struct mv_host_priv *hpriv = host->private_data;
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003754 u32 hp_flags = hpriv->hp_flags;
3755
Jeff Garzik5796d1c2007-10-26 00:03:37 -04003756 switch (board_idx) {
Jeff Garzik47c2b672005-11-12 21:13:17 -05003757 case chip_5080:
3758 hpriv->ops = &mv5xxx_ops;
Jeff Garzikee9ccdf2007-07-12 15:51:22 -04003759 hp_flags |= MV_HP_GEN_I;
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003760
Auke Kok44c10132007-06-08 15:46:36 -07003761 switch (pdev->revision) {
Jeff Garzik47c2b672005-11-12 21:13:17 -05003762 case 0x1:
3763 hp_flags |= MV_HP_ERRATA_50XXB0;
3764 break;
3765 case 0x3:
3766 hp_flags |= MV_HP_ERRATA_50XXB2;
3767 break;
3768 default:
Joe Perchesa44fec12011-04-15 15:51:58 -07003769 dev_warn(&pdev->dev,
3770 "Applying 50XXB2 workarounds to unknown rev\n");
Jeff Garzik47c2b672005-11-12 21:13:17 -05003771 hp_flags |= MV_HP_ERRATA_50XXB2;
3772 break;
3773 }
3774 break;
3775
3776 case chip_504x:
3777 case chip_508x:
3778 hpriv->ops = &mv5xxx_ops;
Jeff Garzikee9ccdf2007-07-12 15:51:22 -04003779 hp_flags |= MV_HP_GEN_I;
Jeff Garzik47c2b672005-11-12 21:13:17 -05003780
Auke Kok44c10132007-06-08 15:46:36 -07003781 switch (pdev->revision) {
Jeff Garzik47c2b672005-11-12 21:13:17 -05003782 case 0x0:
3783 hp_flags |= MV_HP_ERRATA_50XXB0;
3784 break;
3785 case 0x3:
3786 hp_flags |= MV_HP_ERRATA_50XXB2;
3787 break;
3788 default:
Joe Perchesa44fec12011-04-15 15:51:58 -07003789 dev_warn(&pdev->dev,
3790 "Applying B2 workarounds to unknown rev\n");
Jeff Garzik47c2b672005-11-12 21:13:17 -05003791 hp_flags |= MV_HP_ERRATA_50XXB2;
3792 break;
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003793 }
3794 break;
3795
3796 case chip_604x:
3797 case chip_608x:
Jeff Garzik47c2b672005-11-12 21:13:17 -05003798 hpriv->ops = &mv6xxx_ops;
Jeff Garzikee9ccdf2007-07-12 15:51:22 -04003799 hp_flags |= MV_HP_GEN_II;
Jeff Garzik47c2b672005-11-12 21:13:17 -05003800
Auke Kok44c10132007-06-08 15:46:36 -07003801 switch (pdev->revision) {
Jeff Garzik47c2b672005-11-12 21:13:17 -05003802 case 0x7:
Mark Lord65ad7fef2009-04-06 15:24:14 -04003803 mv_60x1b2_errata_pci7(host);
Jeff Garzik47c2b672005-11-12 21:13:17 -05003804 hp_flags |= MV_HP_ERRATA_60X1B2;
3805 break;
3806 case 0x9:
3807 hp_flags |= MV_HP_ERRATA_60X1C0;
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003808 break;
3809 default:
Joe Perchesa44fec12011-04-15 15:51:58 -07003810 dev_warn(&pdev->dev,
3811 "Applying B2 workarounds to unknown rev\n");
Jeff Garzik47c2b672005-11-12 21:13:17 -05003812 hp_flags |= MV_HP_ERRATA_60X1B2;
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003813 break;
3814 }
3815 break;
3816
Jeff Garzike4e7b892006-01-31 12:18:41 -05003817 case chip_7042:
Mark Lord616d4a92008-05-02 02:08:32 -04003818 hp_flags |= MV_HP_PCIE | MV_HP_CUT_THROUGH;
Mark Lord306b30f2007-12-04 14:07:52 -05003819 if (pdev->vendor == PCI_VENDOR_ID_TTI &&
3820 (pdev->device == 0x2300 || pdev->device == 0x2310))
3821 {
Mark Lord4e520032007-12-11 12:58:05 -05003822 /*
3823 * Highpoint RocketRAID PCIe 23xx series cards:
3824 *
3825 * Unconfigured drives are treated as "Legacy"
3826 * by the BIOS, and it overwrites sector 8 with
3827 * a "Lgcy" metadata block prior to Linux boot.
3828 *
3829 * Configured drives (RAID or JBOD) leave sector 8
3830 * alone, but instead overwrite a high numbered
3831 * sector for the RAID metadata. This sector can
3832 * be determined exactly, by truncating the physical
3833 * drive capacity to a nice even GB value.
3834 *
3835 * RAID metadata is at: (dev->n_sectors & ~0xfffff)
3836 *
3837 * Warn the user, lest they think we're just buggy.
3838 */
3839 printk(KERN_WARNING DRV_NAME ": Highpoint RocketRAID"
3840 " BIOS CORRUPTS DATA on all attached drives,"
3841 " regardless of if/how they are configured."
3842 " BEWARE!\n");
3843 printk(KERN_WARNING DRV_NAME ": For data safety, do not"
3844 " use sectors 8-9 on \"Legacy\" drives,"
3845 " and avoid the final two gigabytes on"
3846 " all RocketRAID BIOS initialized drives.\n");
Mark Lord306b30f2007-12-04 14:07:52 -05003847 }
Mark Lord8e7decd2008-05-02 02:07:51 -04003848 /* drop through */
Jeff Garzike4e7b892006-01-31 12:18:41 -05003849 case chip_6042:
3850 hpriv->ops = &mv6xxx_ops;
Jeff Garzike4e7b892006-01-31 12:18:41 -05003851 hp_flags |= MV_HP_GEN_IIE;
Mark Lord616d4a92008-05-02 02:08:32 -04003852 if (board_idx == chip_6042 && mv_pci_cut_through_okay(host))
3853 hp_flags |= MV_HP_CUT_THROUGH;
Jeff Garzike4e7b892006-01-31 12:18:41 -05003854
Auke Kok44c10132007-06-08 15:46:36 -07003855 switch (pdev->revision) {
Mark Lord5cf73bf2008-05-27 17:58:56 -04003856 case 0x2: /* Rev.B0: the first/only public release */
Jeff Garzike4e7b892006-01-31 12:18:41 -05003857 hp_flags |= MV_HP_ERRATA_60X1C0;
3858 break;
3859 default:
Joe Perchesa44fec12011-04-15 15:51:58 -07003860 dev_warn(&pdev->dev,
3861 "Applying 60X1C0 workarounds to unknown rev\n");
Jeff Garzike4e7b892006-01-31 12:18:41 -05003862 hp_flags |= MV_HP_ERRATA_60X1C0;
3863 break;
3864 }
3865 break;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003866 case chip_soc:
Martin Michlmayr29b7e432009-05-04 20:58:50 +02003867 if (soc_is_65n(hpriv))
3868 hpriv->ops = &mv_soc_65n_ops;
3869 else
3870 hpriv->ops = &mv_soc_ops;
Saeed Bisharaeb3a55a2008-08-04 00:52:55 -11003871 hp_flags |= MV_HP_FLAG_SOC | MV_HP_GEN_IIE |
3872 MV_HP_ERRATA_60X1C0;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003873 break;
Jeff Garzike4e7b892006-01-31 12:18:41 -05003874
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003875 default:
Joe Perchesa44fec12011-04-15 15:51:58 -07003876 dev_err(host->dev, "BUG: invalid board index %u\n", board_idx);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003877 return 1;
3878 }
3879
3880 hpriv->hp_flags = hp_flags;
Mark Lord02a121d2007-12-01 13:07:22 -05003881 if (hp_flags & MV_HP_PCIE) {
Mark Lordcae5a292009-04-06 16:43:45 -04003882 hpriv->irq_cause_offset = PCIE_IRQ_CAUSE;
3883 hpriv->irq_mask_offset = PCIE_IRQ_MASK;
Mark Lord02a121d2007-12-01 13:07:22 -05003884 hpriv->unmask_all_irqs = PCIE_UNMASK_ALL_IRQS;
3885 } else {
Mark Lordcae5a292009-04-06 16:43:45 -04003886 hpriv->irq_cause_offset = PCI_IRQ_CAUSE;
3887 hpriv->irq_mask_offset = PCI_IRQ_MASK;
Mark Lord02a121d2007-12-01 13:07:22 -05003888 hpriv->unmask_all_irqs = PCI_UNMASK_ALL_IRQS;
3889 }
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003890
3891 return 0;
3892}
3893
Brett Russ05b308e2005-10-05 17:08:53 -04003894/**
Jeff Garzik47c2b672005-11-12 21:13:17 -05003895 * mv_init_host - Perform some early initialization of the host.
Tejun Heo4447d352007-04-17 23:44:08 +09003896 * @host: ATA host to initialize
Brett Russ05b308e2005-10-05 17:08:53 -04003897 *
3898 * If possible, do an early global reset of the host. Then do
3899 * our port init and clear/unmask all/relevant host interrupts.
3900 *
3901 * LOCKING:
3902 * Inherited from caller.
3903 */
Saeed Bishara1bfeff02009-12-17 01:05:00 -05003904static int mv_init_host(struct ata_host *host)
Brett Russ20f733e2005-09-01 18:26:17 -04003905{
3906 int rc = 0, n_hc, port, hc;
Tejun Heo4447d352007-04-17 23:44:08 +09003907 struct mv_host_priv *hpriv = host->private_data;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003908 void __iomem *mmio = hpriv->base;
Jeff Garzik47c2b672005-11-12 21:13:17 -05003909
Saeed Bishara1bfeff02009-12-17 01:05:00 -05003910 rc = mv_chip_id(host, hpriv->board_idx);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003911 if (rc)
Mark Lord352fab72008-04-19 14:43:42 -04003912 goto done;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003913
Mark Lord1f398472008-05-27 17:54:48 -04003914 if (IS_SOC(hpriv)) {
Mark Lordcae5a292009-04-06 16:43:45 -04003915 hpriv->main_irq_cause_addr = mmio + SOC_HC_MAIN_IRQ_CAUSE;
3916 hpriv->main_irq_mask_addr = mmio + SOC_HC_MAIN_IRQ_MASK;
Mark Lord1f398472008-05-27 17:54:48 -04003917 } else {
Mark Lordcae5a292009-04-06 16:43:45 -04003918 hpriv->main_irq_cause_addr = mmio + PCI_HC_MAIN_IRQ_CAUSE;
3919 hpriv->main_irq_mask_addr = mmio + PCI_HC_MAIN_IRQ_MASK;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05003920 }
Mark Lord352fab72008-04-19 14:43:42 -04003921
Thomas Reitmayr5d0fb2e2009-01-24 20:24:58 +01003922 /* initialize shadow irq mask with register's value */
3923 hpriv->main_irq_mask = readl(hpriv->main_irq_mask_addr);
3924
Mark Lord352fab72008-04-19 14:43:42 -04003925 /* global interrupt mask: 0 == mask everything */
Mark Lordc4de5732008-05-17 13:35:21 -04003926 mv_set_main_irq_mask(host, ~0, 0);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003927
Tejun Heo4447d352007-04-17 23:44:08 +09003928 n_hc = mv_get_hc_count(host->ports[0]->flags);
Jeff Garzikbca1c4e2005-11-12 12:48:15 -05003929
Tejun Heo4447d352007-04-17 23:44:08 +09003930 for (port = 0; port < host->n_ports; port++)
Martin Michlmayr29b7e432009-05-04 20:58:50 +02003931 if (hpriv->ops->read_preamp)
3932 hpriv->ops->read_preamp(hpriv, port, mmio);
Brett Russ20f733e2005-09-01 18:26:17 -04003933
Jeff Garzikc9d39132005-11-13 17:47:51 -05003934 rc = hpriv->ops->reset_hc(hpriv, mmio, n_hc);
Jeff Garzik47c2b672005-11-12 21:13:17 -05003935 if (rc)
Brett Russ20f733e2005-09-01 18:26:17 -04003936 goto done;
Brett Russ20f733e2005-09-01 18:26:17 -04003937
Jeff Garzik522479f2005-11-12 22:14:02 -05003938 hpriv->ops->reset_flash(hpriv, mmio);
Saeed Bishara7bb3c522008-01-30 11:50:45 -11003939 hpriv->ops->reset_bus(host, mmio);
Jeff Garzik47c2b672005-11-12 21:13:17 -05003940 hpriv->ops->enable_leds(hpriv, mmio);
Brett Russ20f733e2005-09-01 18:26:17 -04003941
Tejun Heo4447d352007-04-17 23:44:08 +09003942 for (port = 0; port < host->n_ports; port++) {
Tejun Heocbcdd872007-08-18 13:14:55 +09003943 struct ata_port *ap = host->ports[port];
Jeff Garzik2a47ce02005-11-12 23:05:14 -05003944 void __iomem *port_mmio = mv_port_base(mmio, port);
Tejun Heocbcdd872007-08-18 13:14:55 +09003945
3946 mv_port_init(&ap->ioaddr, port_mmio);
Brett Russ20f733e2005-09-01 18:26:17 -04003947 }
3948
3949 for (hc = 0; hc < n_hc; hc++) {
Brett Russ31961942005-09-30 01:36:00 -04003950 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
3951
3952 VPRINTK("HC%i: HC config=0x%08x HC IRQ cause "
3953 "(before clear)=0x%08x\n", hc,
Mark Lordcae5a292009-04-06 16:43:45 -04003954 readl(hc_mmio + HC_CFG),
3955 readl(hc_mmio + HC_IRQ_CAUSE));
Brett Russ31961942005-09-30 01:36:00 -04003956
3957 /* Clear any currently outstanding hc interrupt conditions */
Mark Lordcae5a292009-04-06 16:43:45 -04003958 writelfl(0, hc_mmio + HC_IRQ_CAUSE);
Brett Russ20f733e2005-09-01 18:26:17 -04003959 }
3960
Mark Lord44c65d12009-04-06 12:29:49 -04003961 if (!IS_SOC(hpriv)) {
3962 /* Clear any currently outstanding host interrupt conditions */
Mark Lordcae5a292009-04-06 16:43:45 -04003963 writelfl(0, mmio + hpriv->irq_cause_offset);
Brett Russ31961942005-09-30 01:36:00 -04003964
Mark Lord44c65d12009-04-06 12:29:49 -04003965 /* and unmask interrupt generation for host regs */
Mark Lordcae5a292009-04-06 16:43:45 -04003966 writelfl(hpriv->unmask_all_irqs, mmio + hpriv->irq_mask_offset);
Mark Lord44c65d12009-04-06 12:29:49 -04003967 }
Jeff Garzikfb621e22007-02-25 04:19:45 -05003968
Mark Lord6be96ac2009-02-19 10:38:04 -05003969 /*
3970 * enable only global host interrupts for now.
3971 * The per-port interrupts get done later as ports are set up.
3972 */
3973 mv_set_main_irq_mask(host, 0, PCI_ERR);
Mark Lord2b748a02009-03-10 22:01:17 -04003974 mv_set_irq_coalescing(host, irq_coalescing_io_count,
3975 irq_coalescing_usecs);
Brett Russ31961942005-09-30 01:36:00 -04003976done:
Brett Russ20f733e2005-09-01 18:26:17 -04003977 return rc;
3978}
3979
Byron Bradleyfbf14e22008-02-10 21:17:30 +00003980static int mv_create_dma_pools(struct mv_host_priv *hpriv, struct device *dev)
3981{
3982 hpriv->crqb_pool = dmam_pool_create("crqb_q", dev, MV_CRQB_Q_SZ,
3983 MV_CRQB_Q_SZ, 0);
3984 if (!hpriv->crqb_pool)
3985 return -ENOMEM;
3986
3987 hpriv->crpb_pool = dmam_pool_create("crpb_q", dev, MV_CRPB_Q_SZ,
3988 MV_CRPB_Q_SZ, 0);
3989 if (!hpriv->crpb_pool)
3990 return -ENOMEM;
3991
3992 hpriv->sg_tbl_pool = dmam_pool_create("sg_tbl", dev, MV_SG_TBL_SZ,
3993 MV_SG_TBL_SZ, 0);
3994 if (!hpriv->sg_tbl_pool)
3995 return -ENOMEM;
3996
3997 return 0;
3998}
3999
Lennert Buytenhek15a32632008-03-27 14:51:39 -04004000static void mv_conf_mbus_windows(struct mv_host_priv *hpriv,
Andrew Lunn63a93322011-12-07 21:48:07 +01004001 const struct mbus_dram_target_info *dram)
Lennert Buytenhek15a32632008-03-27 14:51:39 -04004002{
4003 int i;
4004
4005 for (i = 0; i < 4; i++) {
4006 writel(0, hpriv->base + WINDOW_CTRL(i));
4007 writel(0, hpriv->base + WINDOW_BASE(i));
4008 }
4009
4010 for (i = 0; i < dram->num_cs; i++) {
Andrew Lunn63a93322011-12-07 21:48:07 +01004011 const struct mbus_dram_window *cs = dram->cs + i;
Lennert Buytenhek15a32632008-03-27 14:51:39 -04004012
4013 writel(((cs->size - 1) & 0xffff0000) |
4014 (cs->mbus_attr << 8) |
4015 (dram->mbus_dram_target_id << 4) | 1,
4016 hpriv->base + WINDOW_CTRL(i));
4017 writel(cs->base, hpriv->base + WINDOW_BASE(i));
4018 }
4019}
4020
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004021/**
4022 * mv_platform_probe - handle a positive probe of an soc Marvell
4023 * host
4024 * @pdev: platform device found
4025 *
4026 * LOCKING:
4027 * Inherited from caller.
4028 */
4029static int mv_platform_probe(struct platform_device *pdev)
4030{
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004031 const struct mv_sata_platform_data *mv_platform_data;
Andrew Lunn63a93322011-12-07 21:48:07 +01004032 const struct mbus_dram_target_info *dram;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004033 const struct ata_port_info *ppi[] =
4034 { &mv_port_info[chip_soc], NULL };
4035 struct ata_host *host;
4036 struct mv_host_priv *hpriv;
4037 struct resource *res;
Andrew Lunn97b414e2012-06-10 16:45:37 +02004038 int n_ports = 0, irq = 0;
Dan Carpenter99b80e92012-03-10 12:00:05 +03004039 int rc;
Andrew Lunneee98992012-02-18 22:26:42 +01004040 int port;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004041
Joe Perches06296a12011-04-15 15:52:00 -07004042 ata_print_version_once(&pdev->dev, DRV_VERSION);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004043
4044 /*
4045 * Simple resource validation ..
4046 */
4047 if (unlikely(pdev->num_resources != 2)) {
4048 dev_err(&pdev->dev, "invalid number of resources\n");
4049 return -EINVAL;
4050 }
4051
4052 /*
4053 * Get the register base first
4054 */
4055 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
4056 if (res == NULL)
4057 return -EINVAL;
4058
4059 /* allocate host */
Andrew Lunn97b414e2012-06-10 16:45:37 +02004060 if (pdev->dev.of_node) {
4061 of_property_read_u32(pdev->dev.of_node, "nr-ports", &n_ports);
4062 irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
4063 } else {
Jingoo Han61b8c342013-07-30 17:16:05 +09004064 mv_platform_data = dev_get_platdata(&pdev->dev);
Andrew Lunn97b414e2012-06-10 16:45:37 +02004065 n_ports = mv_platform_data->n_ports;
4066 irq = platform_get_irq(pdev, 0);
4067 }
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004068
4069 host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
4070 hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
4071
4072 if (!host || !hpriv)
4073 return -ENOMEM;
Andrew Lunneee98992012-02-18 22:26:42 +01004074 hpriv->port_clks = devm_kzalloc(&pdev->dev,
4075 sizeof(struct clk *) * n_ports,
4076 GFP_KERNEL);
4077 if (!hpriv->port_clks)
4078 return -ENOMEM;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004079 host->private_data = hpriv;
4080 hpriv->n_ports = n_ports;
Saeed Bishara1bfeff02009-12-17 01:05:00 -05004081 hpriv->board_idx = chip_soc;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004082
4083 host->iomap = NULL;
Saeed Bisharaf1cb0ea2008-02-18 07:42:28 -11004084 hpriv->base = devm_ioremap(&pdev->dev, res->start,
Julia Lawall041b5ea2009-08-06 16:05:08 -07004085 resource_size(res));
Mark Lordcae5a292009-04-06 16:43:45 -04004086 hpriv->base -= SATAHC0_REG_BASE;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004087
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004088 hpriv->clk = clk_get(&pdev->dev, NULL);
4089 if (IS_ERR(hpriv->clk))
Andrew Lunneee98992012-02-18 22:26:42 +01004090 dev_notice(&pdev->dev, "cannot get optional clkdev\n");
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004091 else
Andrew Lunneee98992012-02-18 22:26:42 +01004092 clk_prepare_enable(hpriv->clk);
4093
4094 for (port = 0; port < n_ports; port++) {
4095 char port_number[16];
4096 sprintf(port_number, "%d", port);
4097 hpriv->port_clks[port] = clk_get(&pdev->dev, port_number);
4098 if (!IS_ERR(hpriv->port_clks[port]))
4099 clk_prepare_enable(hpriv->port_clks[port]);
4100 }
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004101
Lennert Buytenhek15a32632008-03-27 14:51:39 -04004102 /*
4103 * (Re-)program MBUS remapping windows if we are asked to.
4104 */
Andrew Lunn63a93322011-12-07 21:48:07 +01004105 dram = mv_mbus_dram_info();
4106 if (dram)
4107 mv_conf_mbus_windows(hpriv, dram);
Lennert Buytenhek15a32632008-03-27 14:51:39 -04004108
Byron Bradleyfbf14e22008-02-10 21:17:30 +00004109 rc = mv_create_dma_pools(hpriv, &pdev->dev);
4110 if (rc)
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004111 goto err;
Byron Bradleyfbf14e22008-02-10 21:17:30 +00004112
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004113 /* initialize adapter */
Saeed Bishara1bfeff02009-12-17 01:05:00 -05004114 rc = mv_init_host(host);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004115 if (rc)
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004116 goto err;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004117
Joe Perchesa44fec12011-04-15 15:51:58 -07004118 dev_info(&pdev->dev, "slots %u ports %d\n",
4119 (unsigned)MV_MAX_Q_DEPTH, host->n_ports);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004120
Andrew Lunn97b414e2012-06-10 16:45:37 +02004121 rc = ata_host_activate(host, irq, mv_interrupt, IRQF_SHARED, &mv6_sht);
Sergei Shtylyovc00a4c92011-10-07 19:22:33 +04004122 if (!rc)
4123 return 0;
4124
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004125err:
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004126 if (!IS_ERR(hpriv->clk)) {
Andrew Lunneee98992012-02-18 22:26:42 +01004127 clk_disable_unprepare(hpriv->clk);
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004128 clk_put(hpriv->clk);
4129 }
Andrew Lunneee98992012-02-18 22:26:42 +01004130 for (port = 0; port < n_ports; port++) {
4131 if (!IS_ERR(hpriv->port_clks[port])) {
4132 clk_disable_unprepare(hpriv->port_clks[port]);
4133 clk_put(hpriv->port_clks[port]);
4134 }
4135 }
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004136
4137 return rc;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004138}
4139
4140/*
4141 *
4142 * mv_platform_remove - unplug a platform interface
4143 * @pdev: platform device
4144 *
4145 * A platform bus SATA device has been unplugged. Perform the needed
4146 * cleanup. Also called on module unload for any active devices.
4147 */
Greg Kroah-Hartman0ec24912012-12-21 13:19:58 -08004148static int mv_platform_remove(struct platform_device *pdev)
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004149{
Sergei Shtylyovd8661922011-10-07 19:24:22 +04004150 struct ata_host *host = platform_get_drvdata(pdev);
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004151 struct mv_host_priv *hpriv = host->private_data;
Andrew Lunneee98992012-02-18 22:26:42 +01004152 int port;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004153 ata_host_detach(host);
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004154
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004155 if (!IS_ERR(hpriv->clk)) {
Andrew Lunneee98992012-02-18 22:26:42 +01004156 clk_disable_unprepare(hpriv->clk);
Saeed Bisharac77a2f42009-12-06 18:26:18 +02004157 clk_put(hpriv->clk);
4158 }
Andrew Lunneee98992012-02-18 22:26:42 +01004159 for (port = 0; port < host->n_ports; port++) {
4160 if (!IS_ERR(hpriv->port_clks[port])) {
4161 clk_disable_unprepare(hpriv->port_clks[port]);
4162 clk_put(hpriv->port_clks[port]);
4163 }
4164 }
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004165 return 0;
4166}
4167
Saeed Bishara6481f2b2009-12-06 18:26:19 +02004168#ifdef CONFIG_PM
4169static int mv_platform_suspend(struct platform_device *pdev, pm_message_t state)
4170{
Sergei Shtylyovd8661922011-10-07 19:24:22 +04004171 struct ata_host *host = platform_get_drvdata(pdev);
Saeed Bishara6481f2b2009-12-06 18:26:19 +02004172 if (host)
4173 return ata_host_suspend(host, state);
4174 else
4175 return 0;
4176}
4177
4178static int mv_platform_resume(struct platform_device *pdev)
4179{
Sergei Shtylyovd8661922011-10-07 19:24:22 +04004180 struct ata_host *host = platform_get_drvdata(pdev);
Andrew Lunn63a93322011-12-07 21:48:07 +01004181 const struct mbus_dram_target_info *dram;
Saeed Bishara6481f2b2009-12-06 18:26:19 +02004182 int ret;
4183
4184 if (host) {
4185 struct mv_host_priv *hpriv = host->private_data;
Andrew Lunn63a93322011-12-07 21:48:07 +01004186
Saeed Bishara6481f2b2009-12-06 18:26:19 +02004187 /*
4188 * (Re-)program MBUS remapping windows if we are asked to.
4189 */
Andrew Lunn63a93322011-12-07 21:48:07 +01004190 dram = mv_mbus_dram_info();
4191 if (dram)
4192 mv_conf_mbus_windows(hpriv, dram);
Saeed Bishara6481f2b2009-12-06 18:26:19 +02004193
4194 /* initialize adapter */
Saeed Bishara1bfeff02009-12-17 01:05:00 -05004195 ret = mv_init_host(host);
Saeed Bishara6481f2b2009-12-06 18:26:19 +02004196 if (ret) {
4197 printk(KERN_ERR DRV_NAME ": Error during HW init\n");
4198 return ret;
4199 }
4200 ata_host_resume(host);
4201 }
4202
4203 return 0;
4204}
4205#else
4206#define mv_platform_suspend NULL
4207#define mv_platform_resume NULL
4208#endif
4209
Andrew Lunn97b414e2012-06-10 16:45:37 +02004210#ifdef CONFIG_OF
Greg Kroah-Hartman0ec24912012-12-21 13:19:58 -08004211static struct of_device_id mv_sata_dt_ids[] = {
Andrew Lunn97b414e2012-06-10 16:45:37 +02004212 { .compatible = "marvell,orion-sata", },
4213 {},
4214};
4215MODULE_DEVICE_TABLE(of, mv_sata_dt_ids);
4216#endif
4217
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004218static struct platform_driver mv_platform_driver = {
Andrew Lunn97b414e2012-06-10 16:45:37 +02004219 .probe = mv_platform_probe,
Greg Kroah-Hartman0ec24912012-12-21 13:19:58 -08004220 .remove = mv_platform_remove,
Andrew Lunn97b414e2012-06-10 16:45:37 +02004221 .suspend = mv_platform_suspend,
4222 .resume = mv_platform_resume,
4223 .driver = {
4224 .name = DRV_NAME,
4225 .owner = THIS_MODULE,
4226 .of_match_table = of_match_ptr(mv_sata_dt_ids),
4227 },
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004228};
4229
4230
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004231#ifdef CONFIG_PCI
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004232static int mv_pci_init_one(struct pci_dev *pdev,
4233 const struct pci_device_id *ent);
Saeed Bisharab2dec482009-12-06 18:26:22 +02004234#ifdef CONFIG_PM
4235static int mv_pci_device_resume(struct pci_dev *pdev);
4236#endif
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004237
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004238
4239static struct pci_driver mv_pci_driver = {
4240 .name = DRV_NAME,
4241 .id_table = mv_pci_tbl,
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004242 .probe = mv_pci_init_one,
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004243 .remove = ata_pci_remove_one,
Saeed Bisharab2dec482009-12-06 18:26:22 +02004244#ifdef CONFIG_PM
4245 .suspend = ata_pci_device_suspend,
4246 .resume = mv_pci_device_resume,
4247#endif
4248
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004249};
4250
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004251/* move to PCI layer or libata core? */
4252static int pci_go_64(struct pci_dev *pdev)
4253{
4254 int rc;
4255
Yang Hongyang6a355282009-04-06 19:01:13 -07004256 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
4257 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004258 if (rc) {
Yang Hongyang284901a2009-04-06 19:01:15 -07004259 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004260 if (rc) {
Joe Perchesa44fec12011-04-15 15:51:58 -07004261 dev_err(&pdev->dev,
4262 "64-bit DMA enable failed\n");
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004263 return rc;
4264 }
4265 }
4266 } else {
Yang Hongyang284901a2009-04-06 19:01:15 -07004267 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004268 if (rc) {
Joe Perchesa44fec12011-04-15 15:51:58 -07004269 dev_err(&pdev->dev, "32-bit DMA enable failed\n");
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004270 return rc;
4271 }
Yang Hongyang284901a2009-04-06 19:01:15 -07004272 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004273 if (rc) {
Joe Perchesa44fec12011-04-15 15:51:58 -07004274 dev_err(&pdev->dev,
4275 "32-bit consistent DMA enable failed\n");
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004276 return rc;
4277 }
4278 }
4279
4280 return rc;
4281}
4282
Brett Russ05b308e2005-10-05 17:08:53 -04004283/**
4284 * mv_print_info - Dump key info to kernel log for perusal.
Tejun Heo4447d352007-04-17 23:44:08 +09004285 * @host: ATA host to print info about
Brett Russ05b308e2005-10-05 17:08:53 -04004286 *
4287 * FIXME: complete this.
4288 *
4289 * LOCKING:
4290 * Inherited from caller.
4291 */
Tejun Heo4447d352007-04-17 23:44:08 +09004292static void mv_print_info(struct ata_host *host)
Brett Russ31961942005-09-30 01:36:00 -04004293{
Tejun Heo4447d352007-04-17 23:44:08 +09004294 struct pci_dev *pdev = to_pci_dev(host->dev);
4295 struct mv_host_priv *hpriv = host->private_data;
Auke Kok44c10132007-06-08 15:46:36 -07004296 u8 scc;
Jeff Garzikc1e4fe72007-07-09 12:29:31 -04004297 const char *scc_s, *gen;
Brett Russ31961942005-09-30 01:36:00 -04004298
4299 /* Use this to determine the HW stepping of the chip so we know
4300 * what errata to workaround
4301 */
Brett Russ31961942005-09-30 01:36:00 -04004302 pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &scc);
4303 if (scc == 0)
4304 scc_s = "SCSI";
4305 else if (scc == 0x01)
4306 scc_s = "RAID";
4307 else
Jeff Garzikc1e4fe72007-07-09 12:29:31 -04004308 scc_s = "?";
4309
4310 if (IS_GEN_I(hpriv))
4311 gen = "I";
4312 else if (IS_GEN_II(hpriv))
4313 gen = "II";
4314 else if (IS_GEN_IIE(hpriv))
4315 gen = "IIE";
4316 else
4317 gen = "?";
Brett Russ31961942005-09-30 01:36:00 -04004318
Joe Perchesa44fec12011-04-15 15:51:58 -07004319 dev_info(&pdev->dev, "Gen-%s %u slots %u ports %s mode IRQ via %s\n",
4320 gen, (unsigned)MV_MAX_Q_DEPTH, host->n_ports,
4321 scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
Brett Russ31961942005-09-30 01:36:00 -04004322}
4323
Brett Russ05b308e2005-10-05 17:08:53 -04004324/**
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004325 * mv_pci_init_one - handle a positive probe of a PCI Marvell host
Brett Russ05b308e2005-10-05 17:08:53 -04004326 * @pdev: PCI device found
4327 * @ent: PCI device ID entry for the matched host
4328 *
4329 * LOCKING:
4330 * Inherited from caller.
4331 */
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004332static int mv_pci_init_one(struct pci_dev *pdev,
4333 const struct pci_device_id *ent)
Brett Russ20f733e2005-09-01 18:26:17 -04004334{
Brett Russ20f733e2005-09-01 18:26:17 -04004335 unsigned int board_idx = (unsigned int)ent->driver_data;
Tejun Heo4447d352007-04-17 23:44:08 +09004336 const struct ata_port_info *ppi[] = { &mv_port_info[board_idx], NULL };
4337 struct ata_host *host;
4338 struct mv_host_priv *hpriv;
Saeed Bisharac4bc7d72009-12-06 18:26:20 +02004339 int n_ports, port, rc;
Brett Russ20f733e2005-09-01 18:26:17 -04004340
Joe Perches06296a12011-04-15 15:52:00 -07004341 ata_print_version_once(&pdev->dev, DRV_VERSION);
Brett Russ20f733e2005-09-01 18:26:17 -04004342
Tejun Heo4447d352007-04-17 23:44:08 +09004343 /* allocate host */
4344 n_ports = mv_get_hc_count(ppi[0]->flags) * MV_PORTS_PER_HC;
4345
4346 host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
4347 hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
4348 if (!host || !hpriv)
4349 return -ENOMEM;
4350 host->private_data = hpriv;
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004351 hpriv->n_ports = n_ports;
Saeed Bishara1bfeff02009-12-17 01:05:00 -05004352 hpriv->board_idx = board_idx;
Tejun Heo4447d352007-04-17 23:44:08 +09004353
4354 /* acquire resources */
Tejun Heo24dc5f32007-01-20 16:00:28 +09004355 rc = pcim_enable_device(pdev);
4356 if (rc)
Brett Russ20f733e2005-09-01 18:26:17 -04004357 return rc;
Brett Russ20f733e2005-09-01 18:26:17 -04004358
Tejun Heo0d5ff562007-02-01 15:06:36 +09004359 rc = pcim_iomap_regions(pdev, 1 << MV_PRIMARY_BAR, DRV_NAME);
4360 if (rc == -EBUSY)
Tejun Heo24dc5f32007-01-20 16:00:28 +09004361 pcim_pin_device(pdev);
Tejun Heo0d5ff562007-02-01 15:06:36 +09004362 if (rc)
Tejun Heo24dc5f32007-01-20 16:00:28 +09004363 return rc;
Tejun Heo4447d352007-04-17 23:44:08 +09004364 host->iomap = pcim_iomap_table(pdev);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004365 hpriv->base = host->iomap[MV_PRIMARY_BAR];
Brett Russ20f733e2005-09-01 18:26:17 -04004366
Jeff Garzikd88184f2007-02-26 01:26:06 -05004367 rc = pci_go_64(pdev);
4368 if (rc)
4369 return rc;
4370
Mark Lordda2fa9b2008-01-26 18:32:45 -05004371 rc = mv_create_dma_pools(hpriv, &pdev->dev);
4372 if (rc)
4373 return rc;
4374
Saeed Bisharac4bc7d72009-12-06 18:26:20 +02004375 for (port = 0; port < host->n_ports; port++) {
4376 struct ata_port *ap = host->ports[port];
4377 void __iomem *port_mmio = mv_port_base(hpriv->base, port);
4378 unsigned int offset = port_mmio - hpriv->base;
4379
4380 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, -1, "mmio");
4381 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, offset, "port");
4382 }
4383
Brett Russ20f733e2005-09-01 18:26:17 -04004384 /* initialize adapter */
Saeed Bishara1bfeff02009-12-17 01:05:00 -05004385 rc = mv_init_host(host);
Tejun Heo24dc5f32007-01-20 16:00:28 +09004386 if (rc)
4387 return rc;
Brett Russ20f733e2005-09-01 18:26:17 -04004388
Mark Lord6d3c30e2009-01-21 10:31:29 -05004389 /* Enable message-switched interrupts, if requested */
4390 if (msi && pci_enable_msi(pdev) == 0)
4391 hpriv->hp_flags |= MV_HP_FLAG_MSI;
Brett Russ20f733e2005-09-01 18:26:17 -04004392
Brett Russ31961942005-09-30 01:36:00 -04004393 mv_dump_pci_cfg(pdev, 0x68);
Tejun Heo4447d352007-04-17 23:44:08 +09004394 mv_print_info(host);
Brett Russ20f733e2005-09-01 18:26:17 -04004395
Tejun Heo4447d352007-04-17 23:44:08 +09004396 pci_set_master(pdev);
Jeff Garzikea8b4db2007-07-17 02:21:50 -04004397 pci_try_set_mwi(pdev);
Tejun Heo4447d352007-04-17 23:44:08 +09004398 return ata_host_activate(host, pdev->irq, mv_interrupt, IRQF_SHARED,
Jeff Garzikc5d3e452007-07-11 18:30:50 -04004399 IS_GEN_I(hpriv) ? &mv5_sht : &mv6_sht);
Brett Russ20f733e2005-09-01 18:26:17 -04004400}
Saeed Bisharab2dec482009-12-06 18:26:22 +02004401
4402#ifdef CONFIG_PM
4403static int mv_pci_device_resume(struct pci_dev *pdev)
4404{
Sergei Shtylyovd8661922011-10-07 19:24:22 +04004405 struct ata_host *host = pci_get_drvdata(pdev);
Saeed Bisharab2dec482009-12-06 18:26:22 +02004406 int rc;
4407
4408 rc = ata_pci_device_do_resume(pdev);
4409 if (rc)
4410 return rc;
4411
4412 /* initialize adapter */
4413 rc = mv_init_host(host);
4414 if (rc)
4415 return rc;
4416
4417 ata_host_resume(host);
4418
4419 return 0;
4420}
4421#endif
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004422#endif
Brett Russ20f733e2005-09-01 18:26:17 -04004423
4424static int __init mv_init(void)
4425{
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004426 int rc = -ENODEV;
4427#ifdef CONFIG_PCI
4428 rc = pci_register_driver(&mv_pci_driver);
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004429 if (rc < 0)
4430 return rc;
4431#endif
4432 rc = platform_driver_register(&mv_platform_driver);
4433
4434#ifdef CONFIG_PCI
4435 if (rc < 0)
4436 pci_unregister_driver(&mv_pci_driver);
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004437#endif
4438 return rc;
Brett Russ20f733e2005-09-01 18:26:17 -04004439}
4440
4441static void __exit mv_exit(void)
4442{
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004443#ifdef CONFIG_PCI
Brett Russ20f733e2005-09-01 18:26:17 -04004444 pci_unregister_driver(&mv_pci_driver);
Saeed Bishara7bb3c522008-01-30 11:50:45 -11004445#endif
Saeed Bisharaf351b2d2008-02-01 18:08:03 -05004446 platform_driver_unregister(&mv_platform_driver);
Brett Russ20f733e2005-09-01 18:26:17 -04004447}
4448
4449MODULE_AUTHOR("Brett Russ");
4450MODULE_DESCRIPTION("SCSI low-level driver for Marvell SATA controllers");
4451MODULE_LICENSE("GPL");
4452MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
4453MODULE_VERSION(DRV_VERSION);
Mark Lord17c5aab2008-04-16 14:56:51 -04004454MODULE_ALIAS("platform:" DRV_NAME);
Brett Russ20f733e2005-09-01 18:26:17 -04004455
Brett Russ20f733e2005-09-01 18:26:17 -04004456module_init(mv_init);
4457module_exit(mv_exit);