projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sata_mv: mbus decode window support
[deliverable/linux.git] / drivers / ata / sata_mv.c
CommitLineData
20f733e7
BR		 1/*
2 * sata_mv.c - Marvell SATA support
3 *
8b260248 4 * Copyright 2005: EMC Corporation, all rights reserved.
e2b1be56 5 * Copyright 2005 Red Hat, Inc. All rights reserved.
20f733e7
BR		 6 *
7 * Please ALWAYS copy linux-ide@vger.kernel.org on emails.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
4a05e209
JG		 24/*
25 sata_mv TODO list:
26
27 1) Needs a full errata audit for all chipsets. I implemented most
28 of the errata workarounds found in the Marvell vendor driver, but
29 I distinctly remember a couple workarounds (one related to PCI-X)
30 are still needed.
31
1fd2e1c2
ML		 32 2) Improve/fix IRQ and error handling sequences.
33
34 3) ATAPI support (Marvell claims the 60xx/70xx chips can do it).
35
36 4) Think about TCQ support here, and for libata in general
37 with controllers that suppport it via host-queuing hardware
38 (a software-only implementation could be a nightmare).
4a05e209
JG		 39
40 5) Investigate problems with PCI Message Signalled Interrupts (MSI).
41
42 6) Add port multiplier support (intermediate)
43
4a05e209
JG		 44 8) Develop a low-power-consumption strategy, and implement it.
45
46 9) [Experiment, low priority] See if ATAPI can be supported using
47 "unknown FIS" or "vendor-specific FIS" support, or something creative
48 like that.
49
50 10) [Experiment, low priority] Investigate interrupt coalescing.
51 Quite often, especially with PCI Message Signalled Interrupts (MSI),
52 the overhead reduced by interrupt mitigation is quite often not
53 worth the latency cost.
54
55 11) [Experiment, Marvell value added] Is it possible to use target
56 mode to cross-connect two Linux boxes with Marvell cards? If so,
57 creating LibATA target mode support would be very interesting.
58
59 Target mode, for those without docs, is the ability to directly
60 connect two SATA controllers.
61
4a05e209
JG		 62*/
63
64
20f733e7
BR		 65#include <linux/kernel.h>
66#include <linux/module.h>
67#include <linux/pci.h>
68#include <linux/init.h>
69#include <linux/blkdev.h>
70#include <linux/delay.h>
71#include <linux/interrupt.h>
8d8b6004 72#include <linux/dmapool.h>
20f733e7 73#include <linux/dma-mapping.h>
a9524a76 74#include <linux/device.h>
f351b2d6
SB		 75#include <linux/platform_device.h>
76#include <linux/ata_platform.h>
15a32632 77#include <linux/mbus.h>
20f733e7 78#include <scsi/scsi_host.h>
193515d5 79#include <scsi/scsi_cmnd.h>
6c08772e 80#include <scsi/scsi_device.h>
20f733e7 81#include <linux/libata.h>
20f733e7
BR		 82
83#define DRV_NAME "sata_mv"
1fd2e1c2 84#define DRV_VERSION "1.20"
20f733e7
BR		 85
86enum {
87 /* BAR's are enumerated in terms of pci_resource_start() terms */
88 MV_PRIMARY_BAR = 0, /* offset 0x10: memory space */
89 MV_IO_BAR = 2, /* offset 0x18: IO space */
90 MV_MISC_BAR = 3, /* offset 0x1c: FLASH, NVRAM, SRAM */
91
92 MV_MAJOR_REG_AREA_SZ = 0x10000, /* 64KB */
93 MV_MINOR_REG_AREA_SZ = 0x2000, /* 8KB */
94
95 MV_PCI_REG_BASE = 0,
96 MV_IRQ_COAL_REG_BASE = 0x18000, /* 6xxx part only */
615ab953
ML		 97 MV_IRQ_COAL_CAUSE = (MV_IRQ_COAL_REG_BASE + 0x08),
98 MV_IRQ_COAL_CAUSE_LO = (MV_IRQ_COAL_REG_BASE + 0x88),
99 MV_IRQ_COAL_CAUSE_HI = (MV_IRQ_COAL_REG_BASE + 0x8c),
100 MV_IRQ_COAL_THRESHOLD = (MV_IRQ_COAL_REG_BASE + 0xcc),
101 MV_IRQ_COAL_TIME_THRESHOLD = (MV_IRQ_COAL_REG_BASE + 0xd0),
102
20f733e7 103 MV_SATAHC0_REG_BASE = 0x20000,
522479fb 104 MV_FLASH_CTL = 0x1046c,
bca1c4eb
JG		 105 MV_GPIO_PORT_CTL = 0x104f0,
106 MV_RESET_CFG = 0x180d8,
20f733e7
BR		 107
108 MV_PCI_REG_SZ = MV_MAJOR_REG_AREA_SZ,
109 MV_SATAHC_REG_SZ = MV_MAJOR_REG_AREA_SZ,
110 MV_SATAHC_ARBTR_REG_SZ = MV_MINOR_REG_AREA_SZ, /* arbiter */
111 MV_PORT_REG_SZ = MV_MINOR_REG_AREA_SZ,
112
31961943
BR		 113 MV_MAX_Q_DEPTH = 32,
114 MV_MAX_Q_DEPTH_MASK = MV_MAX_Q_DEPTH - 1,
115
116 /* CRQB needs alignment on a 1KB boundary. Size == 1KB
117 * CRPB needs alignment on a 256B boundary. Size == 256B
31961943
BR		 118 * ePRD (SG) entries need alignment on a 16B boundary. Size == 16B
119 */
120 MV_CRQB_Q_SZ = (32 * MV_MAX_Q_DEPTH),
121 MV_CRPB_Q_SZ = (8 * MV_MAX_Q_DEPTH),
da2fa9ba 122 MV_MAX_SG_CT = 256,
31961943 123 MV_SG_TBL_SZ = (16 * MV_MAX_SG_CT),
31961943 124
20f733e7
BR		 125 MV_PORTS_PER_HC = 4,
126 /* == (port / MV_PORTS_PER_HC) to determine HC from 0-7 port */
127 MV_PORT_HC_SHIFT = 2,
31961943 128 /* == (port % MV_PORTS_PER_HC) to determine hard port from 0-7 port */
20f733e7
BR		 129 MV_PORT_MASK = 3,
130
131 /* Host Flags */
132 MV_FLAG_DUAL_HC = (1 << 30), /* two SATA Host Controllers */
133 MV_FLAG_IRQ_COALESCE = (1 << 29), /* IRQ coalescing capability */
7bb3c529
SB		 134 /* SoC integrated controllers, no PCI interface */
135 MV_FLAG_SOC = (1 << 28),
136
c5d3e45a 137 MV_COMMON_FLAGS = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
bdd4ddde
JG		 138 ATA_FLAG_MMIO | ATA_FLAG_NO_ATAPI |
139 ATA_FLAG_PIO_POLLING,
47c2b677 140 MV_6XXX_FLAGS = MV_FLAG_IRQ_COALESCE,
20f733e7 141
31961943
BR		 142 CRQB_FLAG_READ = (1 << 0),
143 CRQB_TAG_SHIFT = 1,
c5d3e45a
JG		 144 CRQB_IOID_SHIFT = 6, /* CRQB Gen-II/IIE IO Id shift */
145 CRQB_HOSTQ_SHIFT = 17, /* CRQB Gen-II/IIE HostQueTag shift */
31961943
BR		 146 CRQB_CMD_ADDR_SHIFT = 8,
147 CRQB_CMD_CS = (0x2 << 11),
148 CRQB_CMD_LAST = (1 << 15),
149
150 CRPB_FLAG_STATUS_SHIFT = 8,
c5d3e45a
JG		 151 CRPB_IOID_SHIFT_6 = 5, /* CRPB Gen-II IO Id shift */
152 CRPB_IOID_SHIFT_7 = 7, /* CRPB Gen-IIE IO Id shift */
31961943
BR		 153
154 EPRD_FLAG_END_OF_TBL = (1 << 31),
155
20f733e7
BR		 156 /* PCI interface registers */
157
31961943
BR		 158 PCI_COMMAND_OFS = 0xc00,
159
20f733e7
BR		 160 PCI_MAIN_CMD_STS_OFS = 0xd30,
161 STOP_PCI_MASTER = (1 << 2),
162 PCI_MASTER_EMPTY = (1 << 3),
163 GLOB_SFT_RST = (1 << 4),
164
522479fb
JG		 165 MV_PCI_MODE = 0xd00,
166 MV_PCI_EXP_ROM_BAR_CTL = 0xd2c,
167 MV_PCI_DISC_TIMER = 0xd04,
168 MV_PCI_MSI_TRIGGER = 0xc38,
169 MV_PCI_SERR_MASK = 0xc28,
170 MV_PCI_XBAR_TMOUT = 0x1d04,
171 MV_PCI_ERR_LOW_ADDRESS = 0x1d40,
172 MV_PCI_ERR_HIGH_ADDRESS = 0x1d44,
173 MV_PCI_ERR_ATTRIBUTE = 0x1d48,
174 MV_PCI_ERR_COMMAND = 0x1d50,
175
02a121da
ML		 176 PCI_IRQ_CAUSE_OFS = 0x1d58,
177 PCI_IRQ_MASK_OFS = 0x1d5c,
20f733e7
BR		 178 PCI_UNMASK_ALL_IRQS = 0x7fffff, /* bits 22-0 */
179
02a121da
ML		 180 PCIE_IRQ_CAUSE_OFS = 0x1900,
181 PCIE_IRQ_MASK_OFS = 0x1910,
646a4da5 182 PCIE_UNMASK_ALL_IRQS = 0x40a, /* assorted bits */
02a121da 183
20f733e7
BR		 184 HC_MAIN_IRQ_CAUSE_OFS = 0x1d60,
185 HC_MAIN_IRQ_MASK_OFS = 0x1d64,
f351b2d6
SB		 186 HC_SOC_MAIN_IRQ_CAUSE_OFS = 0x20020,
187 HC_SOC_MAIN_IRQ_MASK_OFS = 0x20024,
20f733e7
BR		 188 PORT0_ERR = (1 << 0), /* shift by port # */
189 PORT0_DONE = (1 << 1), /* shift by port # */
190 HC0_IRQ_PEND = 0x1ff, /* bits 0-8 = HC0's ports */
191 HC_SHIFT = 9, /* bits 9-17 = HC1's ports */
192 PCI_ERR = (1 << 18),
193 TRAN_LO_DONE = (1 << 19), /* 6xxx: IRQ coalescing */
194 TRAN_HI_DONE = (1 << 20), /* 6xxx: IRQ coalescing */
fb621e2f
JG		 195 PORTS_0_3_COAL_DONE = (1 << 8),
196 PORTS_4_7_COAL_DONE = (1 << 17),
20f733e7
BR		 197 PORTS_0_7_COAL_DONE = (1 << 21), /* 6xxx: IRQ coalescing */
198 GPIO_INT = (1 << 22),
199 SELF_INT = (1 << 23),
200 TWSI_INT = (1 << 24),
201 HC_MAIN_RSVD = (0x7f << 25), /* bits 31-25 */
fb621e2f 202 HC_MAIN_RSVD_5 = (0x1fff << 19), /* bits 31-19 */
f351b2d6 203 HC_MAIN_RSVD_SOC = (0x3fffffb << 6), /* bits 31-9, 7-6 */
8b260248 204 HC_MAIN_MASKED_IRQS = (TRAN_LO_DONE | TRAN_HI_DONE |
20f733e7
BR		 205 PORTS_0_7_COAL_DONE | GPIO_INT | TWSI_INT |
206 HC_MAIN_RSVD),
fb621e2f
JG		 207 HC_MAIN_MASKED_IRQS_5 = (PORTS_0_3_COAL_DONE | PORTS_4_7_COAL_DONE |
208 HC_MAIN_RSVD_5),
f351b2d6 209 HC_MAIN_MASKED_IRQS_SOC = (PORTS_0_3_COAL_DONE | HC_MAIN_RSVD_SOC),
20f733e7
BR		 210
211 /* SATAHC registers */
212 HC_CFG_OFS = 0,
213
214 HC_IRQ_CAUSE_OFS = 0x14,
31961943 215 CRPB_DMA_DONE = (1 << 0), /* shift by port # */
20f733e7
BR		 216 HC_IRQ_COAL = (1 << 4), /* IRQ coalescing */
217 DEV_IRQ = (1 << 8), /* shift by port # */
218
219 /* Shadow block registers */
31961943
BR		 220 SHD_BLK_OFS = 0x100,
221 SHD_CTL_AST_OFS = 0x20, /* ofs from SHD_BLK_OFS */
20f733e7
BR		 222
223 /* SATA registers */
224 SATA_STATUS_OFS = 0x300, /* ctrl, err regs follow status */
225 SATA_ACTIVE_OFS = 0x350,
0c58912e 226 SATA_FIS_IRQ_CAUSE_OFS = 0x364,
47c2b677 227 PHY_MODE3 = 0x310,
bca1c4eb
JG		 228 PHY_MODE4 = 0x314,
229 PHY_MODE2 = 0x330,
c9d39130
JG		 230 MV5_PHY_MODE = 0x74,
231 MV5_LT_MODE = 0x30,
232 MV5_PHY_CTL = 0x0C,
bca1c4eb
JG		 233 SATA_INTERFACE_CTL = 0x050,
234
235 MV_M2_PREAMP_MASK = 0x7e0,
20f733e7
BR		 236
237 /* Port registers */
238 EDMA_CFG_OFS = 0,
0c58912e
ML		 239 EDMA_CFG_Q_DEPTH = 0x1f, /* max device queue depth */
240 EDMA_CFG_NCQ = (1 << 5), /* for R/W FPDMA queued */
241 EDMA_CFG_NCQ_GO_ON_ERR = (1 << 14), /* continue on error */
242 EDMA_CFG_RD_BRST_EXT = (1 << 11), /* read burst 512B */
243 EDMA_CFG_WR_BUFF_LEN = (1 << 13), /* write buffer 512B */
20f733e7
BR		 244
245 EDMA_ERR_IRQ_CAUSE_OFS = 0x8,
246 EDMA_ERR_IRQ_MASK_OFS = 0xc,
6c1153e0
JG		 247 EDMA_ERR_D_PAR = (1 << 0), /* UDMA data parity err */
248 EDMA_ERR_PRD_PAR = (1 << 1), /* UDMA PRD parity err */
249 EDMA_ERR_DEV = (1 << 2), /* device error */
250 EDMA_ERR_DEV_DCON = (1 << 3), /* device disconnect */
251 EDMA_ERR_DEV_CON = (1 << 4), /* device connected */
252 EDMA_ERR_SERR = (1 << 5), /* SError bits [WBDST] raised */
c5d3e45a
JG		 253 EDMA_ERR_SELF_DIS = (1 << 7), /* Gen II/IIE self-disable */
254 EDMA_ERR_SELF_DIS_5 = (1 << 8), /* Gen I self-disable */
6c1153e0 255 EDMA_ERR_BIST_ASYNC = (1 << 8), /* BIST FIS or Async Notify */
c5d3e45a 256 EDMA_ERR_TRANS_IRQ_7 = (1 << 8), /* Gen IIE transprt layer irq */
6c1153e0
JG		 257 EDMA_ERR_CRQB_PAR = (1 << 9), /* CRQB parity error */
258 EDMA_ERR_CRPB_PAR = (1 << 10), /* CRPB parity error */
259 EDMA_ERR_INTRL_PAR = (1 << 11), /* internal parity error */
260 EDMA_ERR_IORDY = (1 << 12), /* IORdy timeout */
646a4da5 261
6c1153e0 262 EDMA_ERR_LNK_CTRL_RX = (0xf << 13), /* link ctrl rx error */
646a4da5
ML		 263 EDMA_ERR_LNK_CTRL_RX_0 = (1 << 13), /* transient: CRC err */
264 EDMA_ERR_LNK_CTRL_RX_1 = (1 << 14), /* transient: FIFO err */
265 EDMA_ERR_LNK_CTRL_RX_2 = (1 << 15), /* fatal: caught SYNC */
266 EDMA_ERR_LNK_CTRL_RX_3 = (1 << 16), /* transient: FIS rx err */
267
6c1153e0 268 EDMA_ERR_LNK_DATA_RX = (0xf << 17), /* link data rx error */
646a4da5 269
6c1153e0 270 EDMA_ERR_LNK_CTRL_TX = (0x1f << 21), /* link ctrl tx error */
646a4da5
ML		 271 EDMA_ERR_LNK_CTRL_TX_0 = (1 << 21), /* transient: CRC err */
272 EDMA_ERR_LNK_CTRL_TX_1 = (1 << 22), /* transient: FIFO err */
273 EDMA_ERR_LNK_CTRL_TX_2 = (1 << 23), /* transient: caught SYNC */
274 EDMA_ERR_LNK_CTRL_TX_3 = (1 << 24), /* transient: caught DMAT */
275 EDMA_ERR_LNK_CTRL_TX_4 = (1 << 25), /* transient: FIS collision */
276
6c1153e0 277 EDMA_ERR_LNK_DATA_TX = (0x1f << 26), /* link data tx error */
646a4da5 278
6c1153e0 279 EDMA_ERR_TRANS_PROTO = (1 << 31), /* transport protocol error */
c5d3e45a
JG		 280 EDMA_ERR_OVERRUN_5 = (1 << 5),
281 EDMA_ERR_UNDERRUN_5 = (1 << 6),
646a4da5
ML		 282
283 EDMA_ERR_IRQ_TRANSIENT = EDMA_ERR_LNK_CTRL_RX_0 |
284 EDMA_ERR_LNK_CTRL_RX_1 |
285 EDMA_ERR_LNK_CTRL_RX_3 |
286 EDMA_ERR_LNK_CTRL_TX,
287
bdd4ddde
JG		 288 EDMA_EH_FREEZE = EDMA_ERR_D_PAR |
289 EDMA_ERR_PRD_PAR |
290 EDMA_ERR_DEV_DCON |
291 EDMA_ERR_DEV_CON |
292 EDMA_ERR_SERR |
293 EDMA_ERR_SELF_DIS |
6c1153e0 294 EDMA_ERR_CRQB_PAR |
bdd4ddde
JG		 295 EDMA_ERR_CRPB_PAR |
296 EDMA_ERR_INTRL_PAR |
297 EDMA_ERR_IORDY |
298 EDMA_ERR_LNK_CTRL_RX_2 |
299 EDMA_ERR_LNK_DATA_RX |
300 EDMA_ERR_LNK_DATA_TX |
301 EDMA_ERR_TRANS_PROTO,
302 EDMA_EH_FREEZE_5 = EDMA_ERR_D_PAR |
303 EDMA_ERR_PRD_PAR |
304 EDMA_ERR_DEV_DCON |
305 EDMA_ERR_DEV_CON |
306 EDMA_ERR_OVERRUN_5 |
307 EDMA_ERR_UNDERRUN_5 |
308 EDMA_ERR_SELF_DIS_5 |
6c1153e0 309 EDMA_ERR_CRQB_PAR |
bdd4ddde
JG		 310 EDMA_ERR_CRPB_PAR |
311 EDMA_ERR_INTRL_PAR |
312 EDMA_ERR_IORDY,
20f733e7 313
31961943
BR		 314 EDMA_REQ_Q_BASE_HI_OFS = 0x10,
315 EDMA_REQ_Q_IN_PTR_OFS = 0x14, /* also contains BASE_LO */
31961943
BR		 316
317 EDMA_REQ_Q_OUT_PTR_OFS = 0x18,
318 EDMA_REQ_Q_PTR_SHIFT = 5,
319
320 EDMA_RSP_Q_BASE_HI_OFS = 0x1c,
321 EDMA_RSP_Q_IN_PTR_OFS = 0x20,
322 EDMA_RSP_Q_OUT_PTR_OFS = 0x24, /* also contains BASE_LO */
31961943
BR		 323 EDMA_RSP_Q_PTR_SHIFT = 3,
324
0ea9e179
JG		 325 EDMA_CMD_OFS = 0x28, /* EDMA command register */
326 EDMA_EN = (1 << 0), /* enable EDMA */
327 EDMA_DS = (1 << 1), /* disable EDMA; self-negated */
328 ATA_RST = (1 << 2), /* reset trans/link/phy */
20f733e7 329
c9d39130 330 EDMA_IORDY_TMOUT = 0x34,
bca1c4eb 331 EDMA_ARB_CFG = 0x38,
bca1c4eb 332
31961943
BR		 333 /* Host private flags (hp_flags) */
334 MV_HP_FLAG_MSI = (1 << 0),
47c2b677
JG		 335 MV_HP_ERRATA_50XXB0 = (1 << 1),
336 MV_HP_ERRATA_50XXB2 = (1 << 2),
337 MV_HP_ERRATA_60X1B2 = (1 << 3),
338 MV_HP_ERRATA_60X1C0 = (1 << 4),
e4e7b892 339 MV_HP_ERRATA_XX42A0 = (1 << 5),
0ea9e179
JG		 340 MV_HP_GEN_I = (1 << 6), /* Generation I: 50xx */
341 MV_HP_GEN_II = (1 << 7), /* Generation II: 60xx */
342 MV_HP_GEN_IIE = (1 << 8), /* Generation IIE: 6042/7042 */
02a121da 343 MV_HP_PCIE = (1 << 9), /* PCIe bus/regs: 7042 */
20f733e7 344
31961943 345 /* Port private flags (pp_flags) */
0ea9e179 346 MV_PP_FLAG_EDMA_EN = (1 << 0), /* is EDMA engine enabled? */
72109168 347 MV_PP_FLAG_NCQ_EN = (1 << 1), /* is EDMA set up for NCQ? */
0ea9e179 348 MV_PP_FLAG_HAD_A_RESET = (1 << 2), /* 1st hard reset complete? */
20f733e7
BR		 349};
350
ee9ccdf7
JG		 351#define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
352#define IS_GEN_II(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_II)
e4e7b892 353#define IS_GEN_IIE(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_IIE)
7bb3c529 354#define HAS_PCI(host) (!((host)->ports[0]->flags & MV_FLAG_SOC))
bca1c4eb 355
15a32632
LB		 356#define WINDOW_CTRL(i) (0x20030 + ((i) << 4))
357#define WINDOW_BASE(i) (0x20034 + ((i) << 4))
358
095fec88 359enum {
baf14aa1
JG		 360 /* DMA boundary 0xffff is required by the s/g splitting
361 * we need on /length/ in mv_fill-sg().
362 */
363 MV_DMA_BOUNDARY = 0xffffU,
095fec88 364
0ea9e179
JG		 365 /* mask of register bits containing lower 32 bits
366 * of EDMA request queue DMA address
367 */
095fec88
JG		 368 EDMA_REQ_Q_BASE_LO_MASK = 0xfffffc00U,
369
0ea9e179 370 /* ditto, for response queue */
095fec88
JG		 371 EDMA_RSP_Q_BASE_LO_MASK = 0xffffff00U,
372};
373
522479fb
JG		 374enum chip_type {
375 chip_504x,
376 chip_508x,
377 chip_5080,
378 chip_604x,
379 chip_608x,
e4e7b892
JG		 380 chip_6042,
381 chip_7042,
f351b2d6 382 chip_soc,
522479fb
JG		 383};
384
31961943
BR		 385/* Command ReQuest Block: 32B */
386struct mv_crqb {
e1469874
ML		 387 __le32 sg_addr;
388 __le32 sg_addr_hi;
389 __le16 ctrl_flags;
390 __le16 ata_cmd[11];
31961943 391};
20f733e7 392
e4e7b892 393struct mv_crqb_iie {
e1469874
ML		 394 __le32 addr;
395 __le32 addr_hi;
396 __le32 flags;
397 __le32 len;
398 __le32 ata_cmd[4];
e4e7b892
JG		 399};
400
31961943
BR		 401/* Command ResPonse Block: 8B */
402struct mv_crpb {
e1469874
ML		 403 __le16 id;
404 __le16 flags;
405 __le32 tmstmp;
20f733e7
BR		 406};
407
31961943
BR		 408/* EDMA Physical Region Descriptor (ePRD); A.K.A. SG */
409struct mv_sg {
e1469874
ML		 410 __le32 addr;
411 __le32 flags_size;
412 __le32 addr_hi;
413 __le32 reserved;
31961943 414};
20f733e7 415
31961943
BR		 416struct mv_port_priv {
417 struct mv_crqb *crqb;
418 dma_addr_t crqb_dma;
419 struct mv_crpb *crpb;
420 dma_addr_t crpb_dma;
eb73d558
ML		 421 struct mv_sg *sg_tbl[MV_MAX_Q_DEPTH];
422 dma_addr_t sg_tbl_dma[MV_MAX_Q_DEPTH];
bdd4ddde
JG		 423
424 unsigned int req_idx;
425 unsigned int resp_idx;
426
31961943
BR		 427 u32 pp_flags;
428};
429
bca1c4eb
JG		 430struct mv_port_signal {
431 u32 amps;
432 u32 pre;
433};
434
02a121da
ML		 435struct mv_host_priv {
436 u32 hp_flags;
437 struct mv_port_signal signal[8];
438 const struct mv_hw_ops *ops;
f351b2d6
SB		 439 int n_ports;
440 void __iomem *base;
441 void __iomem *main_cause_reg_addr;
442 void __iomem *main_mask_reg_addr;
02a121da
ML		 443 u32 irq_cause_ofs;
444 u32 irq_mask_ofs;
445 u32 unmask_all_irqs;
da2fa9ba
ML		 446 /*
447 * These consistent DMA memory pools give us guaranteed
448 * alignment for hardware-accessed data structures,
449 * and less memory waste in accomplishing the alignment.
450 */
451 struct dma_pool *crqb_pool;
452 struct dma_pool *crpb_pool;
453 struct dma_pool *sg_tbl_pool;
02a121da
ML		 454};
455
47c2b677 456struct mv_hw_ops {
2a47ce06
JG		 457 void (*phy_errata)(struct mv_host_priv *hpriv, void __iomem *mmio,
458 unsigned int port);
47c2b677
JG		 459 void (*enable_leds)(struct mv_host_priv *hpriv, void __iomem *mmio);
460 void (*read_preamp)(struct mv_host_priv *hpriv, int idx,
461 void __iomem *mmio);
c9d39130
JG		 462 int (*reset_hc)(struct mv_host_priv *hpriv, void __iomem *mmio,
463 unsigned int n_hc);
522479fb 464 void (*reset_flash)(struct mv_host_priv *hpriv, void __iomem *mmio);
7bb3c529 465 void (*reset_bus)(struct ata_host *host, void __iomem *mmio);
47c2b677
JG		 466};
467
20f733e7 468static void mv_irq_clear(struct ata_port *ap);
da3dbb17
TH		 469static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
470static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
471static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
472static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
31961943
BR		 473static int mv_port_start(struct ata_port *ap);
474static void mv_port_stop(struct ata_port *ap);
475static void mv_qc_prep(struct ata_queued_cmd *qc);
e4e7b892 476static void mv_qc_prep_iie(struct ata_queued_cmd *qc);
9a3d9eb0 477static unsigned int mv_qc_issue(struct ata_queued_cmd *qc);
bdd4ddde 478static void mv_error_handler(struct ata_port *ap);
bdd4ddde
JG		 479static void mv_eh_freeze(struct ata_port *ap);
480static void mv_eh_thaw(struct ata_port *ap);
f273827e 481static void mv6_dev_config(struct ata_device *dev);
20f733e7 482
2a47ce06
JG		 483static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
484 unsigned int port);
47c2b677
JG		 485static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
486static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
487 void __iomem *mmio);
c9d39130
JG		 488static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
489 unsigned int n_hc);
522479fb 490static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
7bb3c529 491static void mv5_reset_bus(struct ata_host *host, void __iomem *mmio);
47c2b677 492
2a47ce06
JG		 493static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
494 unsigned int port);
47c2b677
JG		 495static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
496static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
497 void __iomem *mmio);
c9d39130
JG		 498static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
499 unsigned int n_hc);
522479fb 500static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
f351b2d6
SB		 501static void mv_soc_enable_leds(struct mv_host_priv *hpriv,
502 void __iomem *mmio);
503static void mv_soc_read_preamp(struct mv_host_priv *hpriv, int idx,
504 void __iomem *mmio);
505static int mv_soc_reset_hc(struct mv_host_priv *hpriv,
506 void __iomem *mmio, unsigned int n_hc);
507static void mv_soc_reset_flash(struct mv_host_priv *hpriv,
508 void __iomem *mmio);
509static void mv_soc_reset_bus(struct ata_host *host, void __iomem *mmio);
7bb3c529 510static void mv_reset_pci_bus(struct ata_host *host, void __iomem *mmio);
c9d39130
JG		 511static void mv_channel_reset(struct mv_host_priv *hpriv, void __iomem *mmio,
512 unsigned int port_no);
72109168
ML		 513static void mv_edma_cfg(struct mv_port_priv *pp, struct mv_host_priv *hpriv,
514 void __iomem *port_mmio, int want_ncq);
515static int __mv_stop_dma(struct ata_port *ap);
47c2b677 516
eb73d558
ML		 517/* .sg_tablesize is (MV_MAX_SG_CT / 2) in the structures below
518 * because we have to allow room for worst case splitting of
519 * PRDs for 64K boundaries in mv_fill_sg().
520 */
c5d3e45a
JG		 521static struct scsi_host_template mv5_sht = {
522 .module = THIS_MODULE,
523 .name = DRV_NAME,
524 .ioctl = ata_scsi_ioctl,
525 .queuecommand = ata_scsi_queuecmd,
526 .can_queue = ATA_DEF_QUEUE,
527 .this_id = ATA_SHT_THIS_ID,
baf14aa1 528 .sg_tablesize = MV_MAX_SG_CT / 2,
c5d3e45a
JG		 529 .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
530 .emulated = ATA_SHT_EMULATED,
531 .use_clustering = 1,
532 .proc_name = DRV_NAME,
533 .dma_boundary = MV_DMA_BOUNDARY,
3be6cbd7 534 .slave_configure = ata_scsi_slave_config,
c5d3e45a
JG		 535 .slave_destroy = ata_scsi_slave_destroy,
536 .bios_param = ata_std_bios_param,
537};
538
539static struct scsi_host_template mv6_sht = {
20f733e7
BR		 540 .module = THIS_MODULE,
541 .name = DRV_NAME,
542 .ioctl = ata_scsi_ioctl,
543 .queuecommand = ata_scsi_queuecmd,
138bfdd0
ML		 544 .change_queue_depth = ata_scsi_change_queue_depth,
545 .can_queue = MV_MAX_Q_DEPTH - 1,
20f733e7 546 .this_id = ATA_SHT_THIS_ID,
baf14aa1 547 .sg_tablesize = MV_MAX_SG_CT / 2,
20f733e7
BR		 548 .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
549 .emulated = ATA_SHT_EMULATED,
d88184fb 550 .use_clustering = 1,
20f733e7
BR		 551 .proc_name = DRV_NAME,
552 .dma_boundary = MV_DMA_BOUNDARY,
3be6cbd7 553 .slave_configure = ata_scsi_slave_config,
ccf68c34 554 .slave_destroy = ata_scsi_slave_destroy,
20f733e7 555 .bios_param = ata_std_bios_param,
20f733e7
BR		 556};
557
c9d39130 558static const struct ata_port_operations mv5_ops = {
c9d39130
JG		 559 .tf_load = ata_tf_load,
560 .tf_read = ata_tf_read,
561 .check_status = ata_check_status,
562 .exec_command = ata_exec_command,
563 .dev_select = ata_std_dev_select,
564
cffacd85 565 .cable_detect = ata_cable_sata,
c9d39130
JG		 566
567 .qc_prep = mv_qc_prep,
568 .qc_issue = mv_qc_issue,
0d5ff566 569 .data_xfer = ata_data_xfer,
c9d39130 570
c9d39130 571 .irq_clear = mv_irq_clear,
246ce3b6 572 .irq_on = ata_irq_on,
c9d39130 573
bdd4ddde 574 .error_handler = mv_error_handler,
bdd4ddde
JG		 575 .freeze = mv_eh_freeze,
576 .thaw = mv_eh_thaw,
577
c9d39130
JG		 578 .scr_read = mv5_scr_read,
579 .scr_write = mv5_scr_write,
580
581 .port_start = mv_port_start,
582 .port_stop = mv_port_stop,
c9d39130
JG		 583};
584
585static const struct ata_port_operations mv6_ops = {
f273827e 586 .dev_config = mv6_dev_config,
20f733e7
BR		 587 .tf_load = ata_tf_load,
588 .tf_read = ata_tf_read,
589 .check_status = ata_check_status,
590 .exec_command = ata_exec_command,
591 .dev_select = ata_std_dev_select,
592
cffacd85 593 .cable_detect = ata_cable_sata,
20f733e7 594
31961943
BR		 595 .qc_prep = mv_qc_prep,
596 .qc_issue = mv_qc_issue,
0d5ff566 597 .data_xfer = ata_data_xfer,
20f733e7 598
20f733e7 599 .irq_clear = mv_irq_clear,
246ce3b6 600 .irq_on = ata_irq_on,
20f733e7 601
bdd4ddde 602 .error_handler = mv_error_handler,
bdd4ddde
JG		 603 .freeze = mv_eh_freeze,
604 .thaw = mv_eh_thaw,
138bfdd0 605 .qc_defer = ata_std_qc_defer,
bdd4ddde 606
20f733e7
BR		 607 .scr_read = mv_scr_read,
608 .scr_write = mv_scr_write,
609
31961943
BR		 610 .port_start = mv_port_start,
611 .port_stop = mv_port_stop,
20f733e7
BR		 612};
613
e4e7b892 614static const struct ata_port_operations mv_iie_ops = {
e4e7b892
JG		 615 .tf_load = ata_tf_load,
616 .tf_read = ata_tf_read,
617 .check_status = ata_check_status,
618 .exec_command = ata_exec_command,
619 .dev_select = ata_std_dev_select,
620
cffacd85 621 .cable_detect = ata_cable_sata,
e4e7b892
JG		 622
623 .qc_prep = mv_qc_prep_iie,
624 .qc_issue = mv_qc_issue,
0d5ff566 625 .data_xfer = ata_data_xfer,
e4e7b892 626
e4e7b892 627 .irq_clear = mv_irq_clear,
246ce3b6 628 .irq_on = ata_irq_on,
e4e7b892 629
bdd4ddde 630 .error_handler = mv_error_handler,
bdd4ddde
JG		 631 .freeze = mv_eh_freeze,
632 .thaw = mv_eh_thaw,
138bfdd0 633 .qc_defer = ata_std_qc_defer,
bdd4ddde 634
e4e7b892
JG		 635 .scr_read = mv_scr_read,
636 .scr_write = mv_scr_write,
637
638 .port_start = mv_port_start,
639 .port_stop = mv_port_stop,
e4e7b892
JG		 640};
641
98ac62de 642static const struct ata_port_info mv_port_info[] = {
20f733e7 643 { /* chip_504x */
cca3974e 644 .flags = MV_COMMON_FLAGS,
31961943 645 .pio_mask = 0x1f, /* pio0-4 */
bf6263a8 646 .udma_mask = ATA_UDMA6,
c9d39130 647 .port_ops = &mv5_ops,
20f733e7
BR		 648 },
649 { /* chip_508x */
c5d3e45a 650 .flags = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
31961943 651 .pio_mask = 0x1f, /* pio0-4 */
bf6263a8 652 .udma_mask = ATA_UDMA6,
c9d39130 653 .port_ops = &mv5_ops,
20f733e7 654 },
47c2b677 655 { /* chip_5080 */
c5d3e45a 656 .flags = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
47c2b677 657 .pio_mask = 0x1f, /* pio0-4 */
bf6263a8 658 .udma_mask = ATA_UDMA6,
c9d39130 659 .port_ops = &mv5_ops,
47c2b677 660 },
20f733e7 661 { /* chip_604x */
138bfdd0
ML		 662 .flags = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
663 ATA_FLAG_NCQ,
31961943 664 .pio_mask = 0x1f, /* pio0-4 */
bf6263a8 665 .udma_mask = ATA_UDMA6,
c9d39130 666 .port_ops = &mv6_ops,
20f733e7
BR		 667 },
668 { /* chip_608x */
c5d3e45a 669 .flags = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
138bfdd0 670 ATA_FLAG_NCQ | MV_FLAG_DUAL_HC,
31961943 671 .pio_mask = 0x1f, /* pio0-4 */
bf6263a8 672 .udma_mask = ATA_UDMA6,
c9d39130 673 .port_ops = &mv6_ops,
20f733e7 674 },
e4e7b892 675 { /* chip_6042 */
138bfdd0
ML		 676 .flags = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
677 ATA_FLAG_NCQ,
e4e7b892 678 .pio_mask = 0x1f, /* pio0-4 */
bf6263a8 679 .udma_mask = ATA_UDMA6,
e4e7b892
JG		 680 .port_ops = &mv_iie_ops,
681 },
682 { /* chip_7042 */
138bfdd0
ML		 683 .flags = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
684 ATA_FLAG_NCQ,
e4e7b892 685 .pio_mask = 0x1f, /* pio0-4 */
bf6263a8 686 .udma_mask = ATA_UDMA6,
e4e7b892
JG		 687 .port_ops = &mv_iie_ops,
688 },
f351b2d6
SB		 689 { /* chip_soc */
690 .flags = MV_COMMON_FLAGS | MV_FLAG_SOC,
691 .pio_mask = 0x1f, /* pio0-4 */
692 .udma_mask = ATA_UDMA6,
693 .port_ops = &mv_iie_ops,
694 },
20f733e7
BR		 695};
696
3b7d697d 697static const struct pci_device_id mv_pci_tbl[] = {
2d2744fc
JG		 698 { PCI_VDEVICE(MARVELL, 0x5040), chip_504x },
699 { PCI_VDEVICE(MARVELL, 0x5041), chip_504x },
700 { PCI_VDEVICE(MARVELL, 0x5080), chip_5080 },
701 { PCI_VDEVICE(MARVELL, 0x5081), chip_508x },
cfbf723e
AC		 702 /* RocketRAID 1740/174x have different identifiers */
703 { PCI_VDEVICE(TTI, 0x1740), chip_508x },
704 { PCI_VDEVICE(TTI, 0x1742), chip_508x },
2d2744fc
JG		 705
706 { PCI_VDEVICE(MARVELL, 0x6040), chip_604x },
707 { PCI_VDEVICE(MARVELL, 0x6041), chip_604x },
708 { PCI_VDEVICE(MARVELL, 0x6042), chip_6042 },
709 { PCI_VDEVICE(MARVELL, 0x6080), chip_608x },
710 { PCI_VDEVICE(MARVELL, 0x6081), chip_608x },
711
712 { PCI_VDEVICE(ADAPTEC2, 0x0241), chip_604x },
713
d9f9c6bc
FA		 714 /* Adaptec 1430SA */
715 { PCI_VDEVICE(ADAPTEC2, 0x0243), chip_7042 },
716
02a121da 717 /* Marvell 7042 support */
6a3d586d
MT		 718 { PCI_VDEVICE(MARVELL, 0x7042), chip_7042 },
719
02a121da
ML		 720 /* Highpoint RocketRAID PCIe series */
721 { PCI_VDEVICE(TTI, 0x2300), chip_7042 },
722 { PCI_VDEVICE(TTI, 0x2310), chip_7042 },
723
2d2744fc 724 { } /* terminate list */
20f733e7
BR		 725};
726
47c2b677
JG		 727static const struct mv_hw_ops mv5xxx_ops = {
728 .phy_errata = mv5_phy_errata,
729 .enable_leds = mv5_enable_leds,
730 .read_preamp = mv5_read_preamp,
731 .reset_hc = mv5_reset_hc,
522479fb
JG		 732 .reset_flash = mv5_reset_flash,
733 .reset_bus = mv5_reset_bus,
47c2b677
JG		 734};
735
736static const struct mv_hw_ops mv6xxx_ops = {
737 .phy_errata = mv6_phy_errata,
738 .enable_leds = mv6_enable_leds,
739 .read_preamp = mv6_read_preamp,
740 .reset_hc = mv6_reset_hc,
522479fb
JG		 741 .reset_flash = mv6_reset_flash,
742 .reset_bus = mv_reset_pci_bus,
47c2b677
JG		 743};
744
f351b2d6
SB		 745static const struct mv_hw_ops mv_soc_ops = {
746 .phy_errata = mv6_phy_errata,
747 .enable_leds = mv_soc_enable_leds,
748 .read_preamp = mv_soc_read_preamp,
749 .reset_hc = mv_soc_reset_hc,
750 .reset_flash = mv_soc_reset_flash,
751 .reset_bus = mv_soc_reset_bus,
752};
753
20f733e7
BR		 754/*
755 * Functions
756 */
757
758static inline void writelfl(unsigned long data, void __iomem *addr)
759{
760 writel(data, addr);
761 (void) readl(addr); /* flush to avoid PCI posted write */
762}
763
20f733e7
BR		 764static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
765{
766 return (base + MV_SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
767}
768
c9d39130
JG		 769static inline unsigned int mv_hc_from_port(unsigned int port)
770{
771 return port >> MV_PORT_HC_SHIFT;
772}
773
774static inline unsigned int mv_hardport_from_port(unsigned int port)
775{
776 return port & MV_PORT_MASK;
777}
778
779static inline void __iomem *mv_hc_base_from_port(void __iomem *base,
780 unsigned int port)
781{
782 return mv_hc_base(base, mv_hc_from_port(port));
783}
784
20f733e7
BR		 785static inline void __iomem *mv_port_base(void __iomem *base, unsigned int port)
786{
c9d39130 787 return mv_hc_base_from_port(base, port) +
8b260248 788 MV_SATAHC_ARBTR_REG_SZ +
c9d39130 789 (mv_hardport_from_port(port) * MV_PORT_REG_SZ);
20f733e7
BR		 790}
791
f351b2d6
SB		 792static inline void __iomem *mv_host_base(struct ata_host *host)
793{
794 struct mv_host_priv *hpriv = host->private_data;
795 return hpriv->base;
796}
797
20f733e7
BR		 798static inline void __iomem *mv_ap_base(struct ata_port *ap)
799{
f351b2d6 800 return mv_port_base(mv_host_base(ap->host), ap->port_no);
20f733e7
BR		 801}
802
cca3974e 803static inline int mv_get_hc_count(unsigned long port_flags)
31961943 804{
cca3974e 805 return ((port_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
31961943
BR		 806}
807
808static void mv_irq_clear(struct ata_port *ap)
20f733e7 809{
20f733e7
BR		 810}
811
c5d3e45a
JG		 812static void mv_set_edma_ptrs(void __iomem *port_mmio,
813 struct mv_host_priv *hpriv,
814 struct mv_port_priv *pp)
815{
bdd4ddde
JG		 816 u32 index;
817
c5d3e45a
JG		 818 /*
819 * initialize request queue
820 */
bdd4ddde
JG		 821 index = (pp->req_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_REQ_Q_PTR_SHIFT;
822
c5d3e45a
JG		 823 WARN_ON(pp->crqb_dma & 0x3ff);
824 writel((pp->crqb_dma >> 16) >> 16, port_mmio + EDMA_REQ_Q_BASE_HI_OFS);
bdd4ddde 825 writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | index,
c5d3e45a
JG		 826 port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
827
828 if (hpriv->hp_flags & MV_HP_ERRATA_XX42A0)
bdd4ddde 829 writelfl((pp->crqb_dma & 0xffffffff) | index,
c5d3e45a
JG		 830 port_mmio + EDMA_REQ_Q_OUT_PTR_OFS);
831 else
bdd4ddde 832 writelfl(index, port_mmio + EDMA_REQ_Q_OUT_PTR_OFS);
c5d3e45a
JG		 833
834 /*
835 * initialize response queue
836 */
bdd4ddde
JG		 837 index = (pp->resp_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_RSP_Q_PTR_SHIFT;
838
c5d3e45a
JG		 839 WARN_ON(pp->crpb_dma & 0xff);
840 writel((pp->crpb_dma >> 16) >> 16, port_mmio + EDMA_RSP_Q_BASE_HI_OFS);
841
842 if (hpriv->hp_flags & MV_HP_ERRATA_XX42A0)
bdd4ddde 843 writelfl((pp->crpb_dma & 0xffffffff) | index,
c5d3e45a
JG		 844 port_mmio + EDMA_RSP_Q_IN_PTR_OFS);
845 else
bdd4ddde 846 writelfl(index, port_mmio + EDMA_RSP_Q_IN_PTR_OFS);
c5d3e45a 847
bdd4ddde 848 writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) | index,
c5d3e45a 849 port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
c5d3e45a
JG		 850}
851
05b308e1
BR		 852/**
853 * mv_start_dma - Enable eDMA engine
854 * @base: port base address
855 * @pp: port private data
856 *
beec7dbc
TH		 857 * Verify the local cache of the eDMA state is accurate with a
858 * WARN_ON.
05b308e1
BR		 859 *
860 * LOCKING:
861 * Inherited from caller.
862 */
0c58912e 863static void mv_start_dma(struct ata_port *ap, void __iomem *port_mmio,
72109168 864 struct mv_port_priv *pp, u8 protocol)
20f733e7 865{
72109168
ML		 866 int want_ncq = (protocol == ATA_PROT_NCQ);
867
868 if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
869 int using_ncq = ((pp->pp_flags & MV_PP_FLAG_NCQ_EN) != 0);
870 if (want_ncq != using_ncq)
871 __mv_stop_dma(ap);
872 }
c5d3e45a 873 if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN)) {
0c58912e
ML		 874 struct mv_host_priv *hpriv = ap->host->private_data;
875 int hard_port = mv_hardport_from_port(ap->port_no);
876 void __iomem *hc_mmio = mv_hc_base_from_port(
0fca0d6f 877 mv_host_base(ap->host), hard_port);
0c58912e
ML		 878 u32 hc_irq_cause, ipending;
879
bdd4ddde 880 /* clear EDMA event indicators, if any */
f630d562 881 writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
bdd4ddde 882
0c58912e
ML		 883 /* clear EDMA interrupt indicator, if any */
884 hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
885 ipending = (DEV_IRQ << hard_port) |
886 (CRPB_DMA_DONE << hard_port);
887 if (hc_irq_cause & ipending) {
888 writelfl(hc_irq_cause & ~ipending,
889 hc_mmio + HC_IRQ_CAUSE_OFS);
890 }
891
72109168 892 mv_edma_cfg(pp, hpriv, port_mmio, want_ncq);
0c58912e
ML		 893
894 /* clear FIS IRQ Cause */
895 writelfl(0, port_mmio + SATA_FIS_IRQ_CAUSE_OFS);
896
f630d562 897 mv_set_edma_ptrs(port_mmio, hpriv, pp);
bdd4ddde 898
f630d562 899 writelfl(EDMA_EN, port_mmio + EDMA_CMD_OFS);
afb0edd9
BR		 900 pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
901 }
f630d562 902 WARN_ON(!(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS)));
20f733e7
BR		 903}
904
05b308e1 905/**
0ea9e179 906 * __mv_stop_dma - Disable eDMA engine
05b308e1
BR		 907 * @ap: ATA channel to manipulate
908 *
beec7dbc
TH		 909 * Verify the local cache of the eDMA state is accurate with a
910 * WARN_ON.
05b308e1
BR		 911 *
912 * LOCKING:
913 * Inherited from caller.
914 */
0ea9e179 915static int __mv_stop_dma(struct ata_port *ap)
20f733e7 916{
31961943
BR		 917 void __iomem *port_mmio = mv_ap_base(ap);
918 struct mv_port_priv *pp = ap->private_data;
31961943 919 u32 reg;
c5d3e45a 920 int i, err = 0;
31961943 921
4537deb5 922 if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
afb0edd9 923 /* Disable EDMA if active. The disable bit auto clears.
31961943 924 */
31961943
BR		 925 writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
926 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
afb0edd9 927 } else {
beec7dbc 928 WARN_ON(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
2dcb407e 929 }
8b260248 930
31961943
BR		 931 /* now properly wait for the eDMA to stop */
932 for (i = 1000; i > 0; i--) {
933 reg = readl(port_mmio + EDMA_CMD_OFS);
4537deb5 934 if (!(reg & EDMA_EN))
31961943 935 break;
4537deb5 936
31961943
BR		 937 udelay(100);
938 }
939
c5d3e45a 940 if (reg & EDMA_EN) {
f15a1daf 941 ata_port_printk(ap, KERN_ERR, "Unable to stop eDMA\n");
c5d3e45a 942 err = -EIO;
31961943 943 }
c5d3e45a
JG		 944
945 return err;
20f733e7
BR		 946}
947
0ea9e179
JG		 948static int mv_stop_dma(struct ata_port *ap)
949{
950 unsigned long flags;
951 int rc;
952
953 spin_lock_irqsave(&ap->host->lock, flags);
954 rc = __mv_stop_dma(ap);
955 spin_unlock_irqrestore(&ap->host->lock, flags);
956
957 return rc;
958}
959
8a70f8dc 960#ifdef ATA_DEBUG
31961943 961static void mv_dump_mem(void __iomem *start, unsigned bytes)
20f733e7 962{
31961943
BR		 963 int b, w;
964 for (b = 0; b < bytes; ) {
965 DPRINTK("%p: ", start + b);
966 for (w = 0; b < bytes && w < 4; w++) {
2dcb407e 967 printk("%08x ", readl(start + b));
31961943
BR		 968 b += sizeof(u32);
969 }
970 printk("\n");
971 }
31961943 972}
8a70f8dc
JG		 973#endif
974
31961943
BR		 975static void mv_dump_pci_cfg(struct pci_dev *pdev, unsigned bytes)
976{
977#ifdef ATA_DEBUG
978 int b, w;
979 u32 dw;
980 for (b = 0; b < bytes; ) {
981 DPRINTK("%02x: ", b);
982 for (w = 0; b < bytes && w < 4; w++) {
2dcb407e
JG		 983 (void) pci_read_config_dword(pdev, b, &dw);
984 printk("%08x ", dw);
31961943
BR		 985 b += sizeof(u32);
986 }
987 printk("\n");
988 }
989#endif
990}
991static void mv_dump_all_regs(void __iomem *mmio_base, int port,
992 struct pci_dev *pdev)
993{
994#ifdef ATA_DEBUG
8b260248 995 void __iomem *hc_base = mv_hc_base(mmio_base,
31961943
BR		 996 port >> MV_PORT_HC_SHIFT);
997 void __iomem *port_base;
998 int start_port, num_ports, p, start_hc, num_hcs, hc;
999
1000 if (0 > port) {
1001 start_hc = start_port = 0;
1002 num_ports = 8; /* shld be benign for 4 port devs */
1003 num_hcs = 2;
1004 } else {
1005 start_hc = port >> MV_PORT_HC_SHIFT;
1006 start_port = port;
1007 num_ports = num_hcs = 1;
1008 }
8b260248 1009 DPRINTK("All registers for port(s) %u-%u:\n", start_port,
31961943
BR		 1010 num_ports > 1 ? num_ports - 1 : start_port);
1011
1012 if (NULL != pdev) {
1013 DPRINTK("PCI config space regs:\n");
1014 mv_dump_pci_cfg(pdev, 0x68);
1015 }
1016 DPRINTK("PCI regs:\n");
1017 mv_dump_mem(mmio_base+0xc00, 0x3c);
1018 mv_dump_mem(mmio_base+0xd00, 0x34);
1019 mv_dump_mem(mmio_base+0xf00, 0x4);
1020 mv_dump_mem(mmio_base+0x1d00, 0x6c);
1021 for (hc = start_hc; hc < start_hc + num_hcs; hc++) {
d220c37e 1022 hc_base = mv_hc_base(mmio_base, hc);
31961943
BR		 1023 DPRINTK("HC regs (HC %i):\n", hc);
1024 mv_dump_mem(hc_base, 0x1c);
1025 }
1026 for (p = start_port; p < start_port + num_ports; p++) {
1027 port_base = mv_port_base(mmio_base, p);
2dcb407e 1028 DPRINTK("EDMA regs (port %i):\n", p);
31961943 1029 mv_dump_mem(port_base, 0x54);
2dcb407e 1030 DPRINTK("SATA regs (port %i):\n", p);
31961943
BR		 1031 mv_dump_mem(port_base+0x300, 0x60);
1032 }
1033#endif
20f733e7
BR		 1034}
1035
1036static unsigned int mv_scr_offset(unsigned int sc_reg_in)
1037{
1038 unsigned int ofs;
1039
1040 switch (sc_reg_in) {
1041 case SCR_STATUS:
1042 case SCR_CONTROL:
1043 case SCR_ERROR:
1044 ofs = SATA_STATUS_OFS + (sc_reg_in * sizeof(u32));
1045 break;
1046 case SCR_ACTIVE:
1047 ofs = SATA_ACTIVE_OFS; /* active is not with the others */
1048 break;
1049 default:
1050 ofs = 0xffffffffU;
1051 break;
1052 }
1053 return ofs;
1054}
1055
da3dbb17 1056static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
20f733e7
BR		 1057{
1058 unsigned int ofs = mv_scr_offset(sc_reg_in);
1059
da3dbb17
TH		 1060 if (ofs != 0xffffffffU) {
1061 *val = readl(mv_ap_base(ap) + ofs);
1062 return 0;
1063 } else
1064 return -EINVAL;
20f733e7
BR		 1065}
1066
da3dbb17 1067static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
20f733e7
BR		 1068{
1069 unsigned int ofs = mv_scr_offset(sc_reg_in);
1070
da3dbb17 1071 if (ofs != 0xffffffffU) {
20f733e7 1072 writelfl(val, mv_ap_base(ap) + ofs);
da3dbb17
TH		 1073 return 0;
1074 } else
1075 return -EINVAL;
20f733e7
BR		 1076}
1077
f273827e
ML		 1078static void mv6_dev_config(struct ata_device *adev)
1079{
1080 /*
1081 * We don't have hob_nsect when doing NCQ commands on Gen-II.
1082 * See mv_qc_prep() for more info.
1083 */
1084 if (adev->flags & ATA_DFLAG_NCQ)
1085 if (adev->max_sectors > ATA_MAX_SECTORS)
1086 adev->max_sectors = ATA_MAX_SECTORS;
1087}
1088
72109168
ML		 1089static void mv_edma_cfg(struct mv_port_priv *pp, struct mv_host_priv *hpriv,
1090 void __iomem *port_mmio, int want_ncq)
e4e7b892 1091{
0c58912e 1092 u32 cfg;
e4e7b892
JG		 1093
1094 /* set up non-NCQ EDMA configuration */
0c58912e 1095 cfg = EDMA_CFG_Q_DEPTH; /* always 0x1f for *all* chips */
e4e7b892 1096
0c58912e 1097 if (IS_GEN_I(hpriv))
e4e7b892
JG		 1098 cfg |= (1 << 8); /* enab config burst size mask */
1099
0c58912e 1100 else if (IS_GEN_II(hpriv))
e4e7b892
JG		 1101 cfg |= EDMA_CFG_RD_BRST_EXT | EDMA_CFG_WR_BUFF_LEN;
1102
1103 else if (IS_GEN_IIE(hpriv)) {
e728eabe
JG		 1104 cfg |= (1 << 23); /* do not mask PM field in rx'd FIS */
1105 cfg |= (1 << 22); /* enab 4-entry host queue cache */
e4e7b892 1106 cfg |= (1 << 18); /* enab early completion */
e728eabe 1107 cfg |= (1 << 17); /* enab cut-through (dis stor&forwrd) */
e4e7b892
JG		 1108 }
1109
72109168
ML		 1110 if (want_ncq) {
1111 cfg |= EDMA_CFG_NCQ;
1112 pp->pp_flags |= MV_PP_FLAG_NCQ_EN;
1113 } else
1114 pp->pp_flags &= ~MV_PP_FLAG_NCQ_EN;
1115
e4e7b892
JG		 1116 writelfl(cfg, port_mmio + EDMA_CFG_OFS);
1117}
1118
da2fa9ba
ML		 1119static void mv_port_free_dma_mem(struct ata_port *ap)
1120{
1121 struct mv_host_priv *hpriv = ap->host->private_data;
1122 struct mv_port_priv *pp = ap->private_data;
eb73d558 1123 int tag;
da2fa9ba
ML		 1124
1125 if (pp->crqb) {
1126 dma_pool_free(hpriv->crqb_pool, pp->crqb, pp->crqb_dma);
1127 pp->crqb = NULL;
1128 }
1129 if (pp->crpb) {
1130 dma_pool_free(hpriv->crpb_pool, pp->crpb, pp->crpb_dma);
1131 pp->crpb = NULL;
1132 }
eb73d558
ML		 1133 /*
1134 * For GEN_I, there's no NCQ, so we have only a single sg_tbl.
1135 * For later hardware, we have one unique sg_tbl per NCQ tag.
1136 */
1137 for (tag = 0; tag < MV_MAX_Q_DEPTH; ++tag) {
1138 if (pp->sg_tbl[tag]) {
1139 if (tag == 0 || !IS_GEN_I(hpriv))
1140 dma_pool_free(hpriv->sg_tbl_pool,
1141 pp->sg_tbl[tag],
1142 pp->sg_tbl_dma[tag]);
1143 pp->sg_tbl[tag] = NULL;
1144 }
da2fa9ba
ML		 1145 }
1146}
1147
05b308e1
BR		 1148/**
1149 * mv_port_start - Port specific init/start routine.
1150 * @ap: ATA channel to manipulate
1151 *
1152 * Allocate and point to DMA memory, init port private memory,
1153 * zero indices.
1154 *
1155 * LOCKING:
1156 * Inherited from caller.
1157 */
31961943
BR		 1158static int mv_port_start(struct ata_port *ap)
1159{
cca3974e
JG		 1160 struct device *dev = ap->host->dev;
1161 struct mv_host_priv *hpriv = ap->host->private_data;
31961943
BR		 1162 struct mv_port_priv *pp;
1163 void __iomem *port_mmio = mv_ap_base(ap);
0ea9e179 1164 unsigned long flags;
dde20207 1165 int tag;
31961943 1166
24dc5f33 1167 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
6037d6bb 1168 if (!pp)
24dc5f33 1169 return -ENOMEM;
da2fa9ba 1170 ap->private_data = pp;
31961943 1171
da2fa9ba
ML		 1172 pp->crqb = dma_pool_alloc(hpriv->crqb_pool, GFP_KERNEL, &pp->crqb_dma);
1173 if (!pp->crqb)
1174 return -ENOMEM;
1175 memset(pp->crqb, 0, MV_CRQB_Q_SZ);
31961943 1176
da2fa9ba
ML		 1177 pp->crpb = dma_pool_alloc(hpriv->crpb_pool, GFP_KERNEL, &pp->crpb_dma);
1178 if (!pp->crpb)
1179 goto out_port_free_dma_mem;
1180 memset(pp->crpb, 0, MV_CRPB_Q_SZ);
31961943 1181
eb73d558
ML		 1182 /*
1183 * For GEN_I, there's no NCQ, so we only allocate a single sg_tbl.
1184 * For later hardware, we need one unique sg_tbl per NCQ tag.
1185 */
1186 for (tag = 0; tag < MV_MAX_Q_DEPTH; ++tag) {
1187 if (tag == 0 || !IS_GEN_I(hpriv)) {
1188 pp->sg_tbl[tag] = dma_pool_alloc(hpriv->sg_tbl_pool,
1189 GFP_KERNEL, &pp->sg_tbl_dma[tag]);
1190 if (!pp->sg_tbl[tag])
1191 goto out_port_free_dma_mem;
1192 } else {
1193 pp->sg_tbl[tag] = pp->sg_tbl[0];
1194 pp->sg_tbl_dma[tag] = pp->sg_tbl_dma[0];
1195 }
1196 }
31961943 1197
0ea9e179
JG		 1198 spin_lock_irqsave(&ap->host->lock, flags);
1199
72109168 1200 mv_edma_cfg(pp, hpriv, port_mmio, 0);
c5d3e45a 1201 mv_set_edma_ptrs(port_mmio, hpriv, pp);
31961943 1202
0ea9e179
JG		 1203 spin_unlock_irqrestore(&ap->host->lock, flags);
1204
31961943
BR		 1205 /* Don't turn on EDMA here...do it before DMA commands only. Else
1206 * we'll be unable to send non-data, PIO, etc due to restricted access
1207 * to shadow regs.
1208 */
31961943 1209 return 0;
da2fa9ba
ML		 1210
1211out_port_free_dma_mem:
1212 mv_port_free_dma_mem(ap);
1213 return -ENOMEM;
31961943
BR		 1214}
1215
05b308e1
BR		 1216/**
1217 * mv_port_stop - Port specific cleanup/stop routine.
1218 * @ap: ATA channel to manipulate
1219 *
1220 * Stop DMA, cleanup port memory.
1221 *
1222 * LOCKING:
cca3974e 1223 * This routine uses the host lock to protect the DMA stop.
05b308e1 1224 */
31961943
BR		 1225static void mv_port_stop(struct ata_port *ap)
1226{
31961943 1227 mv_stop_dma(ap);
da2fa9ba 1228 mv_port_free_dma_mem(ap);
31961943
BR		 1229}
1230
05b308e1
BR		 1231/**
1232 * mv_fill_sg - Fill out the Marvell ePRD (scatter gather) entries
1233 * @qc: queued command whose SG list to source from
1234 *
1235 * Populate the SG list and mark the last entry.
1236 *
1237 * LOCKING:
1238 * Inherited from caller.
1239 */
6c08772e 1240static void mv_fill_sg(struct ata_queued_cmd *qc)
31961943
BR		 1241{
1242 struct mv_port_priv *pp = qc->ap->private_data;
972c26bd 1243 struct scatterlist *sg;
3be6cbd7 1244 struct mv_sg *mv_sg, *last_sg = NULL;
ff2aeb1e 1245 unsigned int si;
31961943 1246
eb73d558 1247 mv_sg = pp->sg_tbl[qc->tag];
ff2aeb1e 1248 for_each_sg(qc->sg, sg, qc->n_elem, si) {
d88184fb
JG		 1249 dma_addr_t addr = sg_dma_address(sg);
1250 u32 sg_len = sg_dma_len(sg);
22374677 1251
4007b493
OJ		 1252 while (sg_len) {
1253 u32 offset = addr & 0xffff;
1254 u32 len = sg_len;
22374677 1255
4007b493
OJ		 1256 if ((offset + sg_len > 0x10000))
1257 len = 0x10000 - offset;
1258
1259 mv_sg->addr = cpu_to_le32(addr & 0xffffffff);
1260 mv_sg->addr_hi = cpu_to_le32((addr >> 16) >> 16);
6c08772e 1261 mv_sg->flags_size = cpu_to_le32(len & 0xffff);
4007b493
OJ		 1262
1263 sg_len -= len;
1264 addr += len;
1265
3be6cbd7 1266 last_sg = mv_sg;
4007b493 1267 mv_sg++;
4007b493 1268 }
31961943 1269 }
3be6cbd7
JG		 1270
1271 if (likely(last_sg))
1272 last_sg->flags_size |= cpu_to_le32(EPRD_FLAG_END_OF_TBL);
31961943
BR		 1273}
1274
5796d1c4 1275static void mv_crqb_pack_cmd(__le16 *cmdw, u8 data, u8 addr, unsigned last)
31961943 1276{
559eedad 1277 u16 tmp = data | (addr << CRQB_CMD_ADDR_SHIFT) | CRQB_CMD_CS |
31961943 1278 (last ? CRQB_CMD_LAST : 0);
559eedad 1279 *cmdw = cpu_to_le16(tmp);
31961943
BR		 1280}
1281
05b308e1
BR		 1282/**
1283 * mv_qc_prep - Host specific command preparation.
1284 * @qc: queued command to prepare
1285 *
1286 * This routine simply redirects to the general purpose routine
1287 * if command is not DMA. Else, it handles prep of the CRQB
1288 * (command request block), does some sanity checking, and calls
1289 * the SG load routine.
1290 *
1291 * LOCKING:
1292 * Inherited from caller.
1293 */
31961943
BR		 1294static void mv_qc_prep(struct ata_queued_cmd *qc)
1295{
1296 struct ata_port *ap = qc->ap;
1297 struct mv_port_priv *pp = ap->private_data;
e1469874 1298 __le16 *cw;
31961943
BR		 1299 struct ata_taskfile *tf;
1300 u16 flags = 0;
a6432436 1301 unsigned in_index;
31961943 1302
138bfdd0
ML		 1303 if ((qc->tf.protocol != ATA_PROT_DMA) &&
1304 (qc->tf.protocol != ATA_PROT_NCQ))
31961943 1305 return;
20f733e7 1306
31961943
BR		 1307 /* Fill in command request block
1308 */
e4e7b892 1309 if (!(qc->tf.flags & ATA_TFLAG_WRITE))
31961943 1310 flags |= CRQB_FLAG_READ;
beec7dbc 1311 WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
31961943
BR		 1312 flags |= qc->tag << CRQB_TAG_SHIFT;
1313
bdd4ddde
JG		 1314 /* get current queue index from software */
1315 in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
a6432436
ML		 1316
1317 pp->crqb[in_index].sg_addr =
eb73d558 1318 cpu_to_le32(pp->sg_tbl_dma[qc->tag] & 0xffffffff);
a6432436 1319 pp->crqb[in_index].sg_addr_hi =
eb73d558 1320 cpu_to_le32((pp->sg_tbl_dma[qc->tag] >> 16) >> 16);
a6432436 1321 pp->crqb[in_index].ctrl_flags = cpu_to_le16(flags);
31961943 1322
a6432436 1323 cw = &pp->crqb[in_index].ata_cmd[0];
31961943
BR		 1324 tf = &qc->tf;
1325
1326 /* Sadly, the CRQB cannot accomodate all registers--there are
1327 * only 11 bytes...so we must pick and choose required
1328 * registers based on the command. So, we drop feature and
1329 * hob_feature for [RW] DMA commands, but they are needed for
1330 * NCQ. NCQ will drop hob_nsect.
20f733e7 1331 */
31961943
BR		 1332 switch (tf->command) {
1333 case ATA_CMD_READ:
1334 case ATA_CMD_READ_EXT:
1335 case ATA_CMD_WRITE:
1336 case ATA_CMD_WRITE_EXT:
c15d85c8 1337 case ATA_CMD_WRITE_FUA_EXT:
31961943
BR		 1338 mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
1339 break;
31961943
BR		 1340 case ATA_CMD_FPDMA_READ:
1341 case ATA_CMD_FPDMA_WRITE:
8b260248 1342 mv_crqb_pack_cmd(cw++, tf->hob_feature, ATA_REG_FEATURE, 0);
31961943
BR		 1343 mv_crqb_pack_cmd(cw++, tf->feature, ATA_REG_FEATURE, 0);
1344 break;
31961943
BR		 1345 default:
1346 /* The only other commands EDMA supports in non-queued and
1347 * non-NCQ mode are: [RW] STREAM DMA and W DMA FUA EXT, none
1348 * of which are defined/used by Linux. If we get here, this
1349 * driver needs work.
1350 *
1351 * FIXME: modify libata to give qc_prep a return value and
1352 * return error here.
1353 */
1354 BUG_ON(tf->command);
1355 break;
1356 }
1357 mv_crqb_pack_cmd(cw++, tf->nsect, ATA_REG_NSECT, 0);
1358 mv_crqb_pack_cmd(cw++, tf->hob_lbal, ATA_REG_LBAL, 0);
1359 mv_crqb_pack_cmd(cw++, tf->lbal, ATA_REG_LBAL, 0);
1360 mv_crqb_pack_cmd(cw++, tf->hob_lbam, ATA_REG_LBAM, 0);
1361 mv_crqb_pack_cmd(cw++, tf->lbam, ATA_REG_LBAM, 0);
1362 mv_crqb_pack_cmd(cw++, tf->hob_lbah, ATA_REG_LBAH, 0);
1363 mv_crqb_pack_cmd(cw++, tf->lbah, ATA_REG_LBAH, 0);
1364 mv_crqb_pack_cmd(cw++, tf->device, ATA_REG_DEVICE, 0);
1365 mv_crqb_pack_cmd(cw++, tf->command, ATA_REG_CMD, 1); /* last */
1366
e4e7b892
JG		 1367 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1368 return;
1369 mv_fill_sg(qc);
1370}
1371
1372/**
1373 * mv_qc_prep_iie - Host specific command preparation.
1374 * @qc: queued command to prepare
1375 *
1376 * This routine simply redirects to the general purpose routine
1377 * if command is not DMA. Else, it handles prep of the CRQB
1378 * (command request block), does some sanity checking, and calls
1379 * the SG load routine.
1380 *
1381 * LOCKING:
1382 * Inherited from caller.
1383 */
1384static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
1385{
1386 struct ata_port *ap = qc->ap;
1387 struct mv_port_priv *pp = ap->private_data;
1388 struct mv_crqb_iie *crqb;
1389 struct ata_taskfile *tf;
a6432436 1390 unsigned in_index;
e4e7b892
JG		 1391 u32 flags = 0;
1392
138bfdd0
ML		 1393 if ((qc->tf.protocol != ATA_PROT_DMA) &&
1394 (qc->tf.protocol != ATA_PROT_NCQ))
e4e7b892
JG		 1395 return;
1396
e4e7b892
JG		 1397 /* Fill in Gen IIE command request block
1398 */
1399 if (!(qc->tf.flags & ATA_TFLAG_WRITE))
1400 flags |= CRQB_FLAG_READ;
1401
beec7dbc 1402 WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
e4e7b892 1403 flags |= qc->tag << CRQB_TAG_SHIFT;
8c0aeb4a 1404 flags |= qc->tag << CRQB_HOSTQ_SHIFT;
e4e7b892 1405
bdd4ddde
JG		 1406 /* get current queue index from software */
1407 in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
a6432436
ML		 1408
1409 crqb = (struct mv_crqb_iie *) &pp->crqb[in_index];
eb73d558
ML		 1410 crqb->addr = cpu_to_le32(pp->sg_tbl_dma[qc->tag] & 0xffffffff);
1411 crqb->addr_hi = cpu_to_le32((pp->sg_tbl_dma[qc->tag] >> 16) >> 16);
e4e7b892
JG		 1412 crqb->flags = cpu_to_le32(flags);
1413
1414 tf = &qc->tf;
1415 crqb->ata_cmd[0] = cpu_to_le32(
1416 (tf->command << 16) |
1417 (tf->feature << 24)
1418 );
1419 crqb->ata_cmd[1] = cpu_to_le32(
1420 (tf->lbal << 0) |
1421 (tf->lbam << 8) |
1422 (tf->lbah << 16) |
1423 (tf->device << 24)
1424 );
1425 crqb->ata_cmd[2] = cpu_to_le32(
1426 (tf->hob_lbal << 0) |
1427 (tf->hob_lbam << 8) |
1428 (tf->hob_lbah << 16) |
1429 (tf->hob_feature << 24)
1430 );
1431 crqb->ata_cmd[3] = cpu_to_le32(
1432 (tf->nsect << 0) |
1433 (tf->hob_nsect << 8)
1434 );
1435
1436 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
31961943 1437 return;
31961943
BR		 1438 mv_fill_sg(qc);
1439}
1440
05b308e1
BR		 1441/**
1442 * mv_qc_issue - Initiate a command to the host
1443 * @qc: queued command to start
1444 *
1445 * This routine simply redirects to the general purpose routine
1446 * if command is not DMA. Else, it sanity checks our local
1447 * caches of the request producer/consumer indices then enables
1448 * DMA and bumps the request producer index.
1449 *
1450 * LOCKING:
1451 * Inherited from caller.
1452 */
9a3d9eb0 1453static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
31961943 1454{
c5d3e45a
JG		 1455 struct ata_port *ap = qc->ap;
1456 void __iomem *port_mmio = mv_ap_base(ap);
1457 struct mv_port_priv *pp = ap->private_data;
bdd4ddde 1458 u32 in_index;
31961943 1459
138bfdd0
ML		 1460 if ((qc->tf.protocol != ATA_PROT_DMA) &&
1461 (qc->tf.protocol != ATA_PROT_NCQ)) {
31961943
BR		 1462 /* We're about to send a non-EDMA capable command to the
1463 * port. Turn off EDMA so there won't be problems accessing
1464 * shadow block, etc registers.
1465 */
0ea9e179 1466 __mv_stop_dma(ap);
31961943
BR		 1467 return ata_qc_issue_prot(qc);
1468 }
1469
72109168 1470 mv_start_dma(ap, port_mmio, pp, qc->tf.protocol);
bdd4ddde 1471
bdd4ddde 1472 pp->req_idx++;
31961943 1473
bdd4ddde 1474 in_index = (pp->req_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_REQ_Q_PTR_SHIFT;
31961943
BR		 1475
1476 /* and write the request in pointer to kick the EDMA to life */
bdd4ddde
JG		 1477 writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | in_index,
1478 port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
31961943
BR		 1479
1480 return 0;
1481}
1482
05b308e1
BR		 1483/**
1484 * mv_err_intr - Handle error interrupts on the port
1485 * @ap: ATA channel to manipulate
9b358e30 1486 * @reset_allowed: bool: 0 == don't trigger from reset here
05b308e1
BR		 1487 *
1488 * In most cases, just clear the interrupt and move on. However,
1489 * some cases require an eDMA reset, which is done right before
1490 * the COMRESET in mv_phy_reset(). The SERR case requires a
1491 * clear of pending errors in the SATA SERROR register. Finally,
1492 * if the port disabled DMA, update our cached copy to match.
1493 *
1494 * LOCKING:
1495 * Inherited from caller.
1496 */
bdd4ddde 1497static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
31961943
BR		 1498{
1499 void __iomem *port_mmio = mv_ap_base(ap);
bdd4ddde
JG		 1500 u32 edma_err_cause, eh_freeze_mask, serr = 0;
1501 struct mv_port_priv *pp = ap->private_data;
1502 struct mv_host_priv *hpriv = ap->host->private_data;
1503 unsigned int edma_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
1504 unsigned int action = 0, err_mask = 0;
9af5c9c9 1505 struct ata_eh_info *ehi = &ap->link.eh_info;
20f733e7 1506
bdd4ddde 1507 ata_ehi_clear_desc(ehi);
20f733e7 1508
bdd4ddde
JG		 1509 if (!edma_enabled) {
1510 /* just a guess: do we need to do this? should we
1511 * expand this, and do it in all cases?
1512 */
936fd732
TH		 1513 sata_scr_read(&ap->link, SCR_ERROR, &serr);
1514 sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
20f733e7 1515 }
bdd4ddde
JG		 1516
1517 edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
1518
1519 ata_ehi_push_desc(ehi, "edma_err 0x%08x", edma_err_cause);
1520
1521 /*
1522 * all generations share these EDMA error cause bits
1523 */
1524
1525 if (edma_err_cause & EDMA_ERR_DEV)
1526 err_mask |= AC_ERR_DEV;
1527 if (edma_err_cause & (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR |
6c1153e0 1528 EDMA_ERR_CRQB_PAR | EDMA_ERR_CRPB_PAR |
bdd4ddde
JG		 1529 EDMA_ERR_INTRL_PAR)) {
1530 err_mask |= AC_ERR_ATA_BUS;
1531 action |= ATA_EH_HARDRESET;
b64bbc39 1532 ata_ehi_push_desc(ehi, "parity error");
bdd4ddde
JG		 1533 }
1534 if (edma_err_cause & (EDMA_ERR_DEV_DCON | EDMA_ERR_DEV_CON)) {
1535 ata_ehi_hotplugged(ehi);
1536 ata_ehi_push_desc(ehi, edma_err_cause & EDMA_ERR_DEV_DCON ?
b64bbc39 1537 "dev disconnect" : "dev connect");
3606a380 1538 action |= ATA_EH_HARDRESET;
bdd4ddde
JG		 1539 }
1540
ee9ccdf7 1541 if (IS_GEN_I(hpriv)) {
bdd4ddde
JG		 1542 eh_freeze_mask = EDMA_EH_FREEZE_5;
1543
1544 if (edma_err_cause & EDMA_ERR_SELF_DIS_5) {
5ab063e3 1545 pp = ap->private_data;
bdd4ddde 1546 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
b64bbc39 1547 ata_ehi_push_desc(ehi, "EDMA self-disable");
bdd4ddde
JG		 1548 }
1549 } else {
1550 eh_freeze_mask = EDMA_EH_FREEZE;
1551
1552 if (edma_err_cause & EDMA_ERR_SELF_DIS) {
5ab063e3 1553 pp = ap->private_data;
bdd4ddde 1554 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
b64bbc39 1555 ata_ehi_push_desc(ehi, "EDMA self-disable");
bdd4ddde
JG		 1556 }
1557
1558 if (edma_err_cause & EDMA_ERR_SERR) {
936fd732
TH		 1559 sata_scr_read(&ap->link, SCR_ERROR, &serr);
1560 sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
bdd4ddde
JG		 1561 err_mask = AC_ERR_ATA_BUS;
1562 action |= ATA_EH_HARDRESET;
1563 }
afb0edd9 1564 }
20f733e7
BR		 1565
1566 /* Clear EDMA now that SERR cleanup done */
3606a380 1567 writelfl(~edma_err_cause, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
20f733e7 1568
bdd4ddde
JG		 1569 if (!err_mask) {
1570 err_mask = AC_ERR_OTHER;
1571 action |= ATA_EH_HARDRESET;
1572 }
1573
1574 ehi->serror |= serr;
1575 ehi->action |= action;
1576
1577 if (qc)
1578 qc->err_mask |= err_mask;
1579 else
1580 ehi->err_mask |= err_mask;
1581
1582 if (edma_err_cause & eh_freeze_mask)
1583 ata_port_freeze(ap);
1584 else
1585 ata_port_abort(ap);
1586}
1587
1588static void mv_intr_pio(struct ata_port *ap)
1589{
1590 struct ata_queued_cmd *qc;
1591 u8 ata_status;
1592
1593 /* ignore spurious intr if drive still BUSY */
1594 ata_status = readb(ap->ioaddr.status_addr);
1595 if (unlikely(ata_status & ATA_BUSY))
1596 return;
1597
1598 /* get active ATA command */
9af5c9c9 1599 qc = ata_qc_from_tag(ap, ap->link.active_tag);
bdd4ddde
JG		 1600 if (unlikely(!qc)) /* no active tag */
1601 return;
1602 if (qc->tf.flags & ATA_TFLAG_POLLING) /* polling; we don't own qc */
1603 return;
1604
1605 /* and finally, complete the ATA command */
1606 qc->err_mask |= ac_err_mask(ata_status);
1607 ata_qc_complete(qc);
1608}
1609
1610static void mv_intr_edma(struct ata_port *ap)
1611{
1612 void __iomem *port_mmio = mv_ap_base(ap);
1613 struct mv_host_priv *hpriv = ap->host->private_data;
1614 struct mv_port_priv *pp = ap->private_data;
1615 struct ata_queued_cmd *qc;
1616 u32 out_index, in_index;
1617 bool work_done = false;
1618
1619 /* get h/w response queue pointer */
1620 in_index = (readl(port_mmio + EDMA_RSP_Q_IN_PTR_OFS)
1621 >> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
1622
1623 while (1) {
1624 u16 status;
6c1153e0 1625 unsigned int tag;
bdd4ddde
JG		 1626
1627 /* get s/w response queue last-read pointer, and compare */
1628 out_index = pp->resp_idx & MV_MAX_Q_DEPTH_MASK;
1629 if (in_index == out_index)
1630 break;
1631
bdd4ddde 1632 /* 50xx: get active ATA command */
0ea9e179 1633 if (IS_GEN_I(hpriv))
9af5c9c9 1634 tag = ap->link.active_tag;
bdd4ddde 1635
6c1153e0
JG		 1636 /* Gen II/IIE: get active ATA command via tag, to enable
1637 * support for queueing. this works transparently for
1638 * queued and non-queued modes.
bdd4ddde 1639 */
8c0aeb4a
ML		 1640 else
1641 tag = le16_to_cpu(pp->crpb[out_index].id) & 0x1f;
bdd4ddde 1642
6c1153e0 1643 qc = ata_qc_from_tag(ap, tag);
bdd4ddde 1644
cb924419
ML		 1645 /* For non-NCQ mode, the lower 8 bits of status
1646 * are from EDMA_ERR_IRQ_CAUSE_OFS,
1647 * which should be zero if all went well.
bdd4ddde
JG		 1648 */
1649 status = le16_to_cpu(pp->crpb[out_index].flags);
cb924419 1650 if ((status & 0xff) && !(pp->pp_flags & MV_PP_FLAG_NCQ_EN)) {
bdd4ddde
JG		 1651 mv_err_intr(ap, qc);
1652 return;
1653 }
1654
1655 /* and finally, complete the ATA command */
1656 if (qc) {
1657 qc->err_mask |=
1658 ac_err_mask(status >> CRPB_FLAG_STATUS_SHIFT);
1659 ata_qc_complete(qc);
1660 }
1661
0ea9e179 1662 /* advance software response queue pointer, to
bdd4ddde
JG		 1663 * indicate (after the loop completes) to hardware
1664 * that we have consumed a response queue entry.
1665 */
1666 work_done = true;
1667 pp->resp_idx++;
1668 }
1669
1670 if (work_done)
1671 writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) |
1672 (out_index << EDMA_RSP_Q_PTR_SHIFT),
1673 port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
20f733e7
BR		 1674}
1675
05b308e1
BR		 1676/**
1677 * mv_host_intr - Handle all interrupts on the given host controller
cca3974e 1678 * @host: host specific structure
05b308e1
BR		 1679 * @relevant: port error bits relevant to this host controller
1680 * @hc: which host controller we're to look at
1681 *
1682 * Read then write clear the HC interrupt status then walk each
1683 * port connected to the HC and see if it needs servicing. Port
1684 * success ints are reported in the HC interrupt status reg, the
1685 * port error ints are reported in the higher level main
1686 * interrupt status register and thus are passed in via the
1687 * 'relevant' argument.
1688 *
1689 * LOCKING:
1690 * Inherited from caller.
1691 */
cca3974e 1692static void mv_host_intr(struct ata_host *host, u32 relevant, unsigned int hc)
20f733e7 1693{
f351b2d6
SB		 1694 struct mv_host_priv *hpriv = host->private_data;
1695 void __iomem *mmio = hpriv->base;
20f733e7 1696 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
20f733e7 1697 u32 hc_irq_cause;
f351b2d6 1698 int port, port0, last_port;
20f733e7 1699
35177265 1700 if (hc == 0)
20f733e7 1701 port0 = 0;
35177265 1702 else
20f733e7 1703 port0 = MV_PORTS_PER_HC;
20f733e7 1704
f351b2d6
SB		 1705 if (HAS_PCI(host))
1706 last_port = port0 + MV_PORTS_PER_HC;
1707 else
1708 last_port = port0 + hpriv->n_ports;
20f733e7
BR		 1709 /* we'll need the HC success int register in most cases */
1710 hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
bdd4ddde
JG		 1711 if (!hc_irq_cause)
1712 return;
1713
1714 writelfl(~hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
20f733e7
BR		 1715
1716 VPRINTK("ENTER, hc%u relevant=0x%08x HC IRQ cause=0x%08x\n",
2dcb407e 1717 hc, relevant, hc_irq_cause);
20f733e7 1718
8f71efe2 1719 for (port = port0; port < last_port; port++) {
cca3974e 1720 struct ata_port *ap = host->ports[port];
8f71efe2 1721 struct mv_port_priv *pp;
bdd4ddde 1722 int have_err_bits, hard_port, shift;
55d8ca4f 1723
bdd4ddde 1724 if ((!ap) || (ap->flags & ATA_FLAG_DISABLED))
a2c91a88
JG		 1725 continue;
1726
8f71efe2
YL		 1727 pp = ap->private_data;
1728
31961943 1729 shift = port << 1; /* (port * 2) */
20f733e7
BR		 1730 if (port >= MV_PORTS_PER_HC) {
1731 shift++; /* skip bit 8 in the HC Main IRQ reg */
1732 }
bdd4ddde
JG		 1733 have_err_bits = ((PORT0_ERR << shift) & relevant);
1734
1735 if (unlikely(have_err_bits)) {
1736 struct ata_queued_cmd *qc;
8b260248 1737
9af5c9c9 1738 qc = ata_qc_from_tag(ap, ap->link.active_tag);
bdd4ddde
JG		 1739 if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
1740 continue;
1741
1742 mv_err_intr(ap, qc);
1743 continue;
1744 }
1745
1746 hard_port = mv_hardport_from_port(port); /* range 0..3 */
1747
1748 if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
1749 if ((CRPB_DMA_DONE << hard_port) & hc_irq_cause)
1750 mv_intr_edma(ap);
1751 } else {
1752 if ((DEV_IRQ << hard_port) & hc_irq_cause)
1753 mv_intr_pio(ap);
20f733e7
BR		 1754 }
1755 }
1756 VPRINTK("EXIT\n");
1757}
1758
bdd4ddde
JG		 1759static void mv_pci_error(struct ata_host *host, void __iomem *mmio)
1760{
02a121da 1761 struct mv_host_priv *hpriv = host->private_data;
bdd4ddde
JG		 1762 struct ata_port *ap;
1763 struct ata_queued_cmd *qc;
1764 struct ata_eh_info *ehi;
1765 unsigned int i, err_mask, printed = 0;
1766 u32 err_cause;
1767
02a121da 1768 err_cause = readl(mmio + hpriv->irq_cause_ofs);
bdd4ddde
JG		 1769
1770 dev_printk(KERN_ERR, host->dev, "PCI ERROR; PCI IRQ cause=0x%08x\n",
1771 err_cause);
1772
1773 DPRINTK("All regs @ PCI error\n");
1774 mv_dump_all_regs(mmio, -1, to_pci_dev(host->dev));
1775
02a121da 1776 writelfl(0, mmio + hpriv->irq_cause_ofs);
bdd4ddde
JG		 1777
1778 for (i = 0; i < host->n_ports; i++) {
1779 ap = host->ports[i];
936fd732 1780 if (!ata_link_offline(&ap->link)) {
9af5c9c9 1781 ehi = &ap->link.eh_info;
bdd4ddde
JG		 1782 ata_ehi_clear_desc(ehi);
1783 if (!printed++)
1784 ata_ehi_push_desc(ehi,
1785 "PCI err cause 0x%08x", err_cause);
1786 err_mask = AC_ERR_HOST_BUS;
1787 ehi->action = ATA_EH_HARDRESET;
9af5c9c9 1788 qc = ata_qc_from_tag(ap, ap->link.active_tag);
bdd4ddde
JG		 1789 if (qc)
1790 qc->err_mask |= err_mask;
1791 else
1792 ehi->err_mask |= err_mask;
1793
1794 ata_port_freeze(ap);
1795 }
1796 }
1797}
1798
05b308e1 1799/**
c5d3e45a 1800 * mv_interrupt - Main interrupt event handler
05b308e1
BR		 1801 * @irq: unused
1802 * @dev_instance: private data; in this case the host structure
05b308e1
BR		 1803 *
1804 * Read the read only register to determine if any host
1805 * controllers have pending interrupts. If so, call lower level
1806 * routine to handle. Also check for PCI errors which are only
1807 * reported here.
1808 *
8b260248 1809 * LOCKING:
cca3974e 1810 * This routine holds the host lock while processing pending
05b308e1
BR		 1811 * interrupts.
1812 */
7d12e780 1813static irqreturn_t mv_interrupt(int irq, void *dev_instance)
20f733e7 1814{
cca3974e 1815 struct ata_host *host = dev_instance;
f351b2d6 1816 struct mv_host_priv *hpriv = host->private_data;
20f733e7 1817 unsigned int hc, handled = 0, n_hcs;
f351b2d6 1818 void __iomem *mmio = hpriv->base;
646a4da5 1819 u32 irq_stat, irq_mask;
20f733e7 1820
646a4da5 1821 spin_lock(&host->lock);
f351b2d6
SB		 1822
1823 irq_stat = readl(hpriv->main_cause_reg_addr);
1824 irq_mask = readl(hpriv->main_mask_reg_addr);
20f733e7
BR		 1825
1826 /* check the cases where we either have nothing pending or have read
1827 * a bogus register value which can indicate HW removal or PCI fault
1828 */
646a4da5
ML		 1829 if (!(irq_stat & irq_mask) || (0xffffffffU == irq_stat))
1830 goto out_unlock;
20f733e7 1831
cca3974e 1832 n_hcs = mv_get_hc_count(host->ports[0]->flags);
20f733e7 1833
7bb3c529 1834 if (unlikely((irq_stat & PCI_ERR) && HAS_PCI(host))) {
bdd4ddde
JG		 1835 mv_pci_error(host, mmio);
1836 handled = 1;
1837 goto out_unlock; /* skip all other HC irq handling */
1838 }
1839
20f733e7
BR		 1840 for (hc = 0; hc < n_hcs; hc++) {
1841 u32 relevant = irq_stat & (HC0_IRQ_PEND << (hc * HC_SHIFT));
1842 if (relevant) {
cca3974e 1843 mv_host_intr(host, relevant, hc);
bdd4ddde 1844 handled = 1;
20f733e7
BR		 1845 }
1846 }
615ab953 1847
bdd4ddde 1848out_unlock:
cca3974e 1849 spin_unlock(&host->lock);
20f733e7
BR		 1850
1851 return IRQ_RETVAL(handled);
1852}
1853
c9d39130
JG		 1854static void __iomem *mv5_phy_base(void __iomem *mmio, unsigned int port)
1855{
1856 void __iomem *hc_mmio = mv_hc_base_from_port(mmio, port);
1857 unsigned long ofs = (mv_hardport_from_port(port) + 1) * 0x100UL;
1858
1859 return hc_mmio + ofs;
1860}
1861
1862static unsigned int mv5_scr_offset(unsigned int sc_reg_in)
1863{
1864 unsigned int ofs;
1865
1866 switch (sc_reg_in) {
1867 case SCR_STATUS:
1868 case SCR_ERROR:
1869 case SCR_CONTROL:
1870 ofs = sc_reg_in * sizeof(u32);
1871 break;
1872 default:
1873 ofs = 0xffffffffU;
1874 break;
1875 }
1876 return ofs;
1877}
1878
da3dbb17 1879static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
c9d39130 1880{
f351b2d6
SB		 1881 struct mv_host_priv *hpriv = ap->host->private_data;
1882 void __iomem *mmio = hpriv->base;
0d5ff566 1883 void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
c9d39130
JG		 1884 unsigned int ofs = mv5_scr_offset(sc_reg_in);
1885
da3dbb17
TH		 1886 if (ofs != 0xffffffffU) {
1887 *val = readl(addr + ofs);
1888 return 0;
1889 } else
1890 return -EINVAL;
c9d39130
JG		 1891}
1892
da3dbb17 1893static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
c9d39130 1894{
f351b2d6
SB		 1895 struct mv_host_priv *hpriv = ap->host->private_data;
1896 void __iomem *mmio = hpriv->base;
0d5ff566 1897 void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
c9d39130
JG		 1898 unsigned int ofs = mv5_scr_offset(sc_reg_in);
1899
da3dbb17 1900 if (ofs != 0xffffffffU) {
0d5ff566 1901 writelfl(val, addr + ofs);
da3dbb17
TH		 1902 return 0;
1903 } else
1904 return -EINVAL;
c9d39130
JG		 1905}
1906
7bb3c529 1907static void mv5_reset_bus(struct ata_host *host, void __iomem *mmio)
522479fb 1908{
7bb3c529 1909 struct pci_dev *pdev = to_pci_dev(host->dev);
522479fb
JG		 1910 int early_5080;
1911
44c10138 1912 early_5080 = (pdev->device == 0x5080) && (pdev->revision == 0);
522479fb
JG		 1913
1914 if (!early_5080) {
1915 u32 tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
1916 tmp |= (1 << 0);
1917 writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
1918 }
1919
7bb3c529 1920 mv_reset_pci_bus(host, mmio);
522479fb
JG		 1921}
1922
1923static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
1924{
1925 writel(0x0fcfffff, mmio + MV_FLASH_CTL);
1926}
1927
47c2b677 1928static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
ba3fe8fb
JG		 1929 void __iomem *mmio)
1930{
c9d39130
JG		 1931 void __iomem *phy_mmio = mv5_phy_base(mmio, idx);
1932 u32 tmp;
1933
1934 tmp = readl(phy_mmio + MV5_PHY_MODE);
1935
1936 hpriv->signal[idx].pre = tmp & 0x1800; /* bits 12:11 */
1937 hpriv->signal[idx].amps = tmp & 0xe0; /* bits 7:5 */
ba3fe8fb
JG		 1938}
1939
47c2b677 1940static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
ba3fe8fb 1941{
522479fb
JG		 1942 u32 tmp;
1943
1944 writel(0, mmio + MV_GPIO_PORT_CTL);
1945
1946 /* FIXME: handle MV_HP_ERRATA_50XXB2 errata */
1947
1948 tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
1949 tmp |= ~(1 << 0);
1950 writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
ba3fe8fb
JG		 1951}
1952
2a47ce06
JG		 1953static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
1954 unsigned int port)
bca1c4eb 1955{
c9d39130
JG		 1956 void __iomem *phy_mmio = mv5_phy_base(mmio, port);
1957 const u32 mask = (1<<12) | (1<<11) | (1<<7) | (1<<6) | (1<<5);
1958 u32 tmp;
1959 int fix_apm_sq = (hpriv->hp_flags & MV_HP_ERRATA_50XXB0);
1960
1961 if (fix_apm_sq) {
1962 tmp = readl(phy_mmio + MV5_LT_MODE);
1963 tmp |= (1 << 19);
1964 writel(tmp, phy_mmio + MV5_LT_MODE);
1965
1966 tmp = readl(phy_mmio + MV5_PHY_CTL);
1967 tmp &= ~0x3;
1968 tmp |= 0x1;
1969 writel(tmp, phy_mmio + MV5_PHY_CTL);
1970 }
1971
1972 tmp = readl(phy_mmio + MV5_PHY_MODE);
1973 tmp &= ~mask;
1974 tmp |= hpriv->signal[port].pre;
1975 tmp |= hpriv->signal[port].amps;
1976 writel(tmp, phy_mmio + MV5_PHY_MODE);
bca1c4eb
JG		 1977}
1978
c9d39130
JG		 1979
1980#undef ZERO
1981#define ZERO(reg) writel(0, port_mmio + (reg))
1982static void mv5_reset_hc_port(struct mv_host_priv *hpriv, void __iomem *mmio,
1983 unsigned int port)
1984{
1985 void __iomem *port_mmio = mv_port_base(mmio, port);
1986
1987 writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
1988
1989 mv_channel_reset(hpriv, mmio, port);
1990
1991 ZERO(0x028); /* command */
1992 writel(0x11f, port_mmio + EDMA_CFG_OFS);
1993 ZERO(0x004); /* timer */
1994 ZERO(0x008); /* irq err cause */
1995 ZERO(0x00c); /* irq err mask */
1996 ZERO(0x010); /* rq bah */
1997 ZERO(0x014); /* rq inp */
1998 ZERO(0x018); /* rq outp */
1999 ZERO(0x01c); /* respq bah */
2000 ZERO(0x024); /* respq outp */
2001 ZERO(0x020); /* respq inp */
2002 ZERO(0x02c); /* test control */
2003 writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
2004}
2005#undef ZERO
2006
2007#define ZERO(reg) writel(0, hc_mmio + (reg))
2008static void mv5_reset_one_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
2009 unsigned int hc)
47c2b677 2010{
c9d39130
JG		 2011 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
2012 u32 tmp;
2013
2014 ZERO(0x00c);
2015 ZERO(0x010);
2016 ZERO(0x014);
2017 ZERO(0x018);
2018
2019 tmp = readl(hc_mmio + 0x20);
2020 tmp &= 0x1c1c1c1c;
2021 tmp |= 0x03030303;
2022 writel(tmp, hc_mmio + 0x20);
2023}
2024#undef ZERO
2025
2026static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
2027 unsigned int n_hc)
2028{
2029 unsigned int hc, port;
2030
2031 for (hc = 0; hc < n_hc; hc++) {
2032 for (port = 0; port < MV_PORTS_PER_HC; port++)
2033 mv5_reset_hc_port(hpriv, mmio,
2034 (hc * MV_PORTS_PER_HC) + port);
2035
2036 mv5_reset_one_hc(hpriv, mmio, hc);
2037 }
2038
2039 return 0;
47c2b677
JG		 2040}
2041
101ffae2
JG		 2042#undef ZERO
2043#define ZERO(reg) writel(0, mmio + (reg))
7bb3c529 2044static void mv_reset_pci_bus(struct ata_host *host, void __iomem *mmio)
101ffae2 2045{
02a121da 2046 struct mv_host_priv *hpriv = host->private_data;
101ffae2
JG		 2047 u32 tmp;
2048
2049 tmp = readl(mmio + MV_PCI_MODE);
2050 tmp &= 0xff00ffff;
2051 writel(tmp, mmio + MV_PCI_MODE);
2052
2053 ZERO(MV_PCI_DISC_TIMER);
2054 ZERO(MV_PCI_MSI_TRIGGER);
2055 writel(0x000100ff, mmio + MV_PCI_XBAR_TMOUT);
2056 ZERO(HC_MAIN_IRQ_MASK_OFS);
2057 ZERO(MV_PCI_SERR_MASK);
02a121da
ML		 2058 ZERO(hpriv->irq_cause_ofs);
2059 ZERO(hpriv->irq_mask_ofs);
101ffae2
JG		 2060 ZERO(MV_PCI_ERR_LOW_ADDRESS);
2061 ZERO(MV_PCI_ERR_HIGH_ADDRESS);
2062 ZERO(MV_PCI_ERR_ATTRIBUTE);
2063 ZERO(MV_PCI_ERR_COMMAND);
2064}
2065#undef ZERO
2066
2067static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
2068{
2069 u32 tmp;
2070
2071 mv5_reset_flash(hpriv, mmio);
2072
2073 tmp = readl(mmio + MV_GPIO_PORT_CTL);
2074 tmp &= 0x3;
2075 tmp |= (1 << 5) | (1 << 6);
2076 writel(tmp, mmio + MV_GPIO_PORT_CTL);
2077}
2078
2079/**
2080 * mv6_reset_hc - Perform the 6xxx global soft reset
2081 * @mmio: base address of the HBA
2082 *
2083 * This routine only applies to 6xxx parts.
2084 *
2085 * LOCKING:
2086 * Inherited from caller.
2087 */
c9d39130
JG		 2088static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
2089 unsigned int n_hc)
101ffae2
JG		 2090{
2091 void __iomem *reg = mmio + PCI_MAIN_CMD_STS_OFS;
2092 int i, rc = 0;
2093 u32 t;
2094
2095 /* Following procedure defined in PCI "main command and status
2096 * register" table.
2097 */
2098 t = readl(reg);
2099 writel(t | STOP_PCI_MASTER, reg);
2100
2101 for (i = 0; i < 1000; i++) {
2102 udelay(1);
2103 t = readl(reg);
2dcb407e 2104 if (PCI_MASTER_EMPTY & t)
101ffae2 2105 break;
101ffae2
JG		 2106 }
2107 if (!(PCI_MASTER_EMPTY & t)) {
2108 printk(KERN_ERR DRV_NAME ": PCI master won't flush\n");
2109 rc = 1;
2110 goto done;
2111 }
2112
2113 /* set reset */
2114 i = 5;
2115 do {
2116 writel(t | GLOB_SFT_RST, reg);
2117 t = readl(reg);
2118 udelay(1);
2119 } while (!(GLOB_SFT_RST & t) && (i-- > 0));
2120
2121 if (!(GLOB_SFT_RST & t)) {
2122 printk(KERN_ERR DRV_NAME ": can't set global reset\n");
2123 rc = 1;
2124 goto done;
2125 }
2126
2127 /* clear reset and *reenable the PCI master* (not mentioned in spec) */
2128 i = 5;
2129 do {
2130 writel(t & ~(GLOB_SFT_RST | STOP_PCI_MASTER), reg);
2131 t = readl(reg);
2132 udelay(1);
2133 } while ((GLOB_SFT_RST & t) && (i-- > 0));
2134
2135 if (GLOB_SFT_RST & t) {
2136 printk(KERN_ERR DRV_NAME ": can't clear global reset\n");
2137 rc = 1;
2138 }
2139done:
2140 return rc;
2141}
2142
47c2b677 2143static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
ba3fe8fb
JG		 2144 void __iomem *mmio)
2145{
2146 void __iomem *port_mmio;
2147 u32 tmp;
2148
ba3fe8fb
JG		 2149 tmp = readl(mmio + MV_RESET_CFG);
2150 if ((tmp & (1 << 0)) == 0) {
47c2b677 2151 hpriv->signal[idx].amps = 0x7 << 8;
ba3fe8fb
JG		 2152 hpriv->signal[idx].pre = 0x1 << 5;
2153 return;
2154 }
2155
2156 port_mmio = mv_port_base(mmio, idx);
2157 tmp = readl(port_mmio + PHY_MODE2);
2158
2159 hpriv->signal[idx].amps = tmp & 0x700; /* bits 10:8 */
2160 hpriv->signal[idx].pre = tmp & 0xe0; /* bits 7:5 */
2161}
2162
47c2b677 2163static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
ba3fe8fb 2164{
47c2b677 2165 writel(0x00000060, mmio + MV_GPIO_PORT_CTL);
ba3fe8fb
JG		 2166}
2167
c9d39130 2168static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
2a47ce06 2169 unsigned int port)
bca1c4eb 2170{
c9d39130
JG		 2171 void __iomem *port_mmio = mv_port_base(mmio, port);
2172
bca1c4eb 2173 u32 hp_flags = hpriv->hp_flags;
47c2b677
JG		 2174 int fix_phy_mode2 =
2175 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
bca1c4eb 2176 int fix_phy_mode4 =
47c2b677
JG		 2177 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
2178 u32 m2, tmp;
2179
2180 if (fix_phy_mode2) {
2181 m2 = readl(port_mmio + PHY_MODE2);
2182 m2 &= ~(1 << 16);
2183 m2 |= (1 << 31);
2184 writel(m2, port_mmio + PHY_MODE2);
2185
2186 udelay(200);
2187
2188 m2 = readl(port_mmio + PHY_MODE2);
2189 m2 &= ~((1 << 16) | (1 << 31));
2190 writel(m2, port_mmio + PHY_MODE2);
2191
2192 udelay(200);
2193 }
2194
2195 /* who knows what this magic does */
2196 tmp = readl(port_mmio + PHY_MODE3);
2197 tmp &= ~0x7F800000;
2198 tmp |= 0x2A800000;
2199 writel(tmp, port_mmio + PHY_MODE3);
bca1c4eb
JG		 2200
2201 if (fix_phy_mode4) {
47c2b677 2202 u32 m4;
bca1c4eb
JG		 2203
2204 m4 = readl(port_mmio + PHY_MODE4);
47c2b677
JG		 2205
2206 if (hp_flags & MV_HP_ERRATA_60X1B2)
2207 tmp = readl(port_mmio + 0x310);
bca1c4eb
JG		 2208
2209 m4 = (m4 & ~(1 << 1)) | (1 << 0);
2210
2211 writel(m4, port_mmio + PHY_MODE4);
47c2b677
JG		 2212
2213 if (hp_flags & MV_HP_ERRATA_60X1B2)
2214 writel(tmp, port_mmio + 0x310);
bca1c4eb
JG		 2215 }
2216
2217 /* Revert values of pre-emphasis and signal amps to the saved ones */
2218 m2 = readl(port_mmio + PHY_MODE2);
2219
2220 m2 &= ~MV_M2_PREAMP_MASK;
2a47ce06
JG		 2221 m2 |= hpriv->signal[port].amps;
2222 m2 |= hpriv->signal[port].pre;
47c2b677 2223 m2 &= ~(1 << 16);
bca1c4eb 2224
e4e7b892
JG		 2225 /* according to mvSata 3.6.1, some IIE values are fixed */
2226 if (IS_GEN_IIE(hpriv)) {
2227 m2 &= ~0xC30FF01F;
2228 m2 |= 0x0000900F;
2229 }
2230
bca1c4eb
JG		 2231 writel(m2, port_mmio + PHY_MODE2);
2232}
2233
f351b2d6
SB		 2234/* TODO: use the generic LED interface to configure the SATA Presence */
2235/* & Acitivy LEDs on the board */
2236static void mv_soc_enable_leds(struct mv_host_priv *hpriv,
2237 void __iomem *mmio)
2238{
2239 return;
2240}
2241
2242static void mv_soc_read_preamp(struct mv_host_priv *hpriv, int idx,
2243 void __iomem *mmio)
2244{
2245 void __iomem *port_mmio;
2246 u32 tmp;
2247
2248 port_mmio = mv_port_base(mmio, idx);
2249 tmp = readl(port_mmio + PHY_MODE2);
2250
2251 hpriv->signal[idx].amps = tmp & 0x700; /* bits 10:8 */
2252 hpriv->signal[idx].pre = tmp & 0xe0; /* bits 7:5 */
2253}
2254
2255#undef ZERO
2256#define ZERO(reg) writel(0, port_mmio + (reg))
2257static void mv_soc_reset_hc_port(struct mv_host_priv *hpriv,
2258 void __iomem *mmio, unsigned int port)
2259{
2260 void __iomem *port_mmio = mv_port_base(mmio, port);
2261
2262 writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
2263
2264 mv_channel_reset(hpriv, mmio, port);
2265
2266 ZERO(0x028); /* command */
2267 writel(0x101f, port_mmio + EDMA_CFG_OFS);
2268 ZERO(0x004); /* timer */
2269 ZERO(0x008); /* irq err cause */
2270 ZERO(0x00c); /* irq err mask */
2271 ZERO(0x010); /* rq bah */
2272 ZERO(0x014); /* rq inp */
2273 ZERO(0x018); /* rq outp */
2274 ZERO(0x01c); /* respq bah */
2275 ZERO(0x024); /* respq outp */
2276 ZERO(0x020); /* respq inp */
2277 ZERO(0x02c); /* test control */
2278 writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
2279}
2280
2281#undef ZERO
2282
2283#define ZERO(reg) writel(0, hc_mmio + (reg))
2284static void mv_soc_reset_one_hc(struct mv_host_priv *hpriv,
2285 void __iomem *mmio)
2286{
2287 void __iomem *hc_mmio = mv_hc_base(mmio, 0);
2288
2289 ZERO(0x00c);
2290 ZERO(0x010);
2291 ZERO(0x014);
2292
2293}
2294
2295#undef ZERO
2296
2297static int mv_soc_reset_hc(struct mv_host_priv *hpriv,
2298 void __iomem *mmio, unsigned int n_hc)
2299{
2300 unsigned int port;
2301
2302 for (port = 0; port < hpriv->n_ports; port++)
2303 mv_soc_reset_hc_port(hpriv, mmio, port);
2304
2305 mv_soc_reset_one_hc(hpriv, mmio);
2306
2307 return 0;
2308}
2309
2310static void mv_soc_reset_flash(struct mv_host_priv *hpriv,
2311 void __iomem *mmio)
2312{
2313 return;
2314}
2315
2316static void mv_soc_reset_bus(struct ata_host *host, void __iomem *mmio)
2317{
2318 return;
2319}
2320
c9d39130
JG		 2321static void mv_channel_reset(struct mv_host_priv *hpriv, void __iomem *mmio,
2322 unsigned int port_no)
2323{
2324 void __iomem *port_mmio = mv_port_base(mmio, port_no);
2325
2326 writelfl(ATA_RST, port_mmio + EDMA_CMD_OFS);
2327
ee9ccdf7 2328 if (IS_GEN_II(hpriv)) {
c9d39130 2329 u32 ifctl = readl(port_mmio + SATA_INTERFACE_CTL);
eb46d684
ML		 2330 ifctl |= (1 << 7); /* enable gen2i speed */
2331 ifctl = (ifctl & 0xfff) | 0x9b1000; /* from chip spec */
c9d39130
JG		 2332 writelfl(ifctl, port_mmio + SATA_INTERFACE_CTL);
2333 }
2334
2335 udelay(25); /* allow reset propagation */
2336
2337 /* Spec never mentions clearing the bit. Marvell's driver does
2338 * clear the bit, however.
2339 */
2340 writelfl(0, port_mmio + EDMA_CMD_OFS);
2341
2342 hpriv->ops->phy_errata(hpriv, mmio, port_no);
2343
ee9ccdf7 2344 if (IS_GEN_I(hpriv))
c9d39130
JG		 2345 mdelay(1);
2346}
2347
05b308e1 2348/**
bdd4ddde 2349 * mv_phy_reset - Perform eDMA reset followed by COMRESET
05b308e1
BR		 2350 * @ap: ATA channel to manipulate
2351 *
2352 * Part of this is taken from __sata_phy_reset and modified to
2353 * not sleep since this routine gets called from interrupt level.
2354 *
2355 * LOCKING:
2356 * Inherited from caller. This is coded to safe to call at
2357 * interrupt level, i.e. it does not sleep.
31961943 2358 */
bdd4ddde
JG		 2359static void mv_phy_reset(struct ata_port *ap, unsigned int *class,
2360 unsigned long deadline)
20f733e7 2361{
095fec88 2362 struct mv_port_priv *pp = ap->private_data;
cca3974e 2363 struct mv_host_priv *hpriv = ap->host->private_data;
20f733e7 2364 void __iomem *port_mmio = mv_ap_base(ap);
22374677
JG		 2365 int retry = 5;
2366 u32 sstatus;
20f733e7
BR		 2367
2368 VPRINTK("ENTER, port %u, mmio 0x%p\n", ap->port_no, port_mmio);
2369
da3dbb17
TH		 2370#ifdef DEBUG
2371 {
2372 u32 sstatus, serror, scontrol;
2373
2374 mv_scr_read(ap, SCR_STATUS, &sstatus);
2375 mv_scr_read(ap, SCR_ERROR, &serror);
2376 mv_scr_read(ap, SCR_CONTROL, &scontrol);
2377 DPRINTK("S-regs after ATA_RST: SStat 0x%08x SErr 0x%08x "
2d79ab8f 2378 "SCtrl 0x%08x\n", sstatus, serror, scontrol);
da3dbb17
TH		 2379 }
2380#endif
20f733e7 2381
22374677
JG		 2382 /* Issue COMRESET via SControl */
2383comreset_retry:
936fd732 2384 sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x301);
bdd4ddde 2385 msleep(1);
22374677 2386
936fd732 2387 sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x300);
bdd4ddde 2388 msleep(20);
22374677 2389
31961943 2390 do {
936fd732 2391 sata_scr_read(&ap->link, SCR_STATUS, &sstatus);
62f1d0e6 2392 if (((sstatus & 0x3) == 3) || ((sstatus & 0x3) == 0))
31961943 2393 break;
22374677 2394
bdd4ddde 2395 msleep(1);
c5d3e45a 2396 } while (time_before(jiffies, deadline));
20f733e7 2397
22374677 2398 /* work around errata */
ee9ccdf7 2399 if (IS_GEN_II(hpriv) &&
22374677
JG		 2400 (sstatus != 0x0) && (sstatus != 0x113) && (sstatus != 0x123) &&
2401 (retry-- > 0))
2402 goto comreset_retry;
095fec88 2403
da3dbb17
TH		 2404#ifdef DEBUG
2405 {
2406 u32 sstatus, serror, scontrol;
2407
2408 mv_scr_read(ap, SCR_STATUS, &sstatus);
2409 mv_scr_read(ap, SCR_ERROR, &serror);
2410 mv_scr_read(ap, SCR_CONTROL, &scontrol);
2411 DPRINTK("S-regs after PHY wake: SStat 0x%08x SErr 0x%08x "
2412 "SCtrl 0x%08x\n", sstatus, serror, scontrol);
2413 }
2414#endif
31961943 2415
936fd732 2416 if (ata_link_offline(&ap->link)) {
bdd4ddde 2417 *class = ATA_DEV_NONE;
20f733e7
BR		 2418 return;
2419 }
2420
22374677
JG		 2421 /* even after SStatus reflects that device is ready,
2422 * it seems to take a while for link to be fully
2423 * established (and thus Status no longer 0x80/0x7F),
2424 * so we poll a bit for that, here.
2425 */
2426 retry = 20;
2427 while (1) {
2428 u8 drv_stat = ata_check_status(ap);
2429 if ((drv_stat != 0x80) && (drv_stat != 0x7f))
2430 break;
bdd4ddde 2431 msleep(500);
22374677
JG		 2432 if (retry-- <= 0)
2433 break;
bdd4ddde
JG		 2434 if (time_after(jiffies, deadline))
2435 break;
22374677
JG		 2436 }
2437
bdd4ddde
JG		 2438 /* FIXME: if we passed the deadline, the following
2439 * code probably produces an invalid result
2440 */
20f733e7 2441
bdd4ddde 2442 /* finally, read device signature from TF registers */
3f19859e 2443 *class = ata_dev_try_classify(ap->link.device, 1, NULL);
095fec88
JG		 2444
2445 writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2446
bdd4ddde 2447 WARN_ON(pp->pp_flags & MV_PP_FLAG_EDMA_EN);
095fec88 2448
bca1c4eb 2449 VPRINTK("EXIT\n");
20f733e7
BR		 2450}
2451
cc0680a5 2452static int mv_prereset(struct ata_link *link, unsigned long deadline)
22374677 2453{
cc0680a5 2454 struct ata_port *ap = link->ap;
bdd4ddde 2455 struct mv_port_priv *pp = ap->private_data;
cc0680a5 2456 struct ata_eh_context *ehc = &link->eh_context;
bdd4ddde 2457 int rc;
0ea9e179 2458
bdd4ddde
JG		 2459 rc = mv_stop_dma(ap);
2460 if (rc)
2461 ehc->i.action |= ATA_EH_HARDRESET;
2462
2463 if (!(pp->pp_flags & MV_PP_FLAG_HAD_A_RESET)) {
2464 pp->pp_flags |= MV_PP_FLAG_HAD_A_RESET;
2465 ehc->i.action |= ATA_EH_HARDRESET;
2466 }
2467
2468 /* if we're about to do hardreset, nothing more to do */
2469 if (ehc->i.action & ATA_EH_HARDRESET)
2470 return 0;
2471
cc0680a5 2472 if (ata_link_online(link))
bdd4ddde
JG		 2473 rc = ata_wait_ready(ap, deadline);
2474 else
2475 rc = -ENODEV;
2476
2477 return rc;
22374677
JG		 2478}
2479
cc0680a5 2480static int mv_hardreset(struct ata_link *link, unsigned int *class,
bdd4ddde 2481 unsigned long deadline)
31961943 2482{
cc0680a5 2483 struct ata_port *ap = link->ap;
bdd4ddde 2484 struct mv_host_priv *hpriv = ap->host->private_data;
f351b2d6 2485 void __iomem *mmio = hpriv->base;
31961943 2486
bdd4ddde 2487 mv_stop_dma(ap);
31961943 2488
bdd4ddde 2489 mv_channel_reset(hpriv, mmio, ap->port_no);
31961943 2490
bdd4ddde
JG		 2491 mv_phy_reset(ap, class, deadline);
2492
2493 return 0;
2494}
2495
cc0680a5 2496static void mv_postreset(struct ata_link *link, unsigned int *classes)
bdd4ddde 2497{
cc0680a5 2498 struct ata_port *ap = link->ap;
bdd4ddde
JG		 2499 u32 serr;
2500
2501 /* print link status */
cc0680a5 2502 sata_print_link_status(link);
31961943 2503
bdd4ddde 2504 /* clear SError */
cc0680a5
TH		 2505 sata_scr_read(link, SCR_ERROR, &serr);
2506 sata_scr_write_flush(link, SCR_ERROR, serr);
bdd4ddde
JG		 2507
2508 /* bail out if no device is present */
2509 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2510 DPRINTK("EXIT, no device\n");
2511 return;
9b358e30 2512 }
bdd4ddde
JG		 2513
2514 /* set up device control */
2515 iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
2516}
2517
2518static void mv_error_handler(struct ata_port *ap)
2519{
2520 ata_do_eh(ap, mv_prereset, ata_std_softreset,
2521 mv_hardreset, mv_postreset);
2522}
2523
bdd4ddde
JG		 2524static void mv_eh_freeze(struct ata_port *ap)
2525{
f351b2d6 2526 struct mv_host_priv *hpriv = ap->host->private_data;
bdd4ddde
JG		 2527 unsigned int hc = (ap->port_no > 3) ? 1 : 0;
2528 u32 tmp, mask;
2529 unsigned int shift;
2530
2531 /* FIXME: handle coalescing completion events properly */
2532
2533 shift = ap->port_no * 2;
2534 if (hc > 0)
2535 shift++;
2536
2537 mask = 0x3 << shift;
2538
2539 /* disable assertion of portN err, done events */
f351b2d6
SB		 2540 tmp = readl(hpriv->main_mask_reg_addr);
2541 writelfl(tmp & ~mask, hpriv->main_mask_reg_addr);
bdd4ddde
JG		 2542}
2543
2544static void mv_eh_thaw(struct ata_port *ap)
2545{
f351b2d6
SB		 2546 struct mv_host_priv *hpriv = ap->host->private_data;
2547 void __iomem *mmio = hpriv->base;
bdd4ddde
JG		 2548 unsigned int hc = (ap->port_no > 3) ? 1 : 0;
2549 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
2550 void __iomem *port_mmio = mv_ap_base(ap);
2551 u32 tmp, mask, hc_irq_cause;
2552 unsigned int shift, hc_port_no = ap->port_no;
2553
2554 /* FIXME: handle coalescing completion events properly */
2555
2556 shift = ap->port_no * 2;
2557 if (hc > 0) {
2558 shift++;
2559 hc_port_no -= 4;
2560 }
2561
2562 mask = 0x3 << shift;
2563
2564 /* clear EDMA errors on this port */
2565 writel(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2566
2567 /* clear pending irq events */
2568 hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
2569 hc_irq_cause &= ~(1 << hc_port_no); /* clear CRPB-done */
2570 hc_irq_cause &= ~(1 << (hc_port_no + 8)); /* clear Device int */
2571 writel(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
2572
2573 /* enable assertion of portN err, done events */
f351b2d6
SB		 2574 tmp = readl(hpriv->main_mask_reg_addr);
2575 writelfl(tmp | mask, hpriv->main_mask_reg_addr);
31961943
BR		 2576}
2577
05b308e1
BR		 2578/**
2579 * mv_port_init - Perform some early initialization on a single port.
2580 * @port: libata data structure storing shadow register addresses
2581 * @port_mmio: base address of the port
2582 *
2583 * Initialize shadow register mmio addresses, clear outstanding
2584 * interrupts on the port, and unmask interrupts for the future
2585 * start of the port.
2586 *
2587 * LOCKING:
2588 * Inherited from caller.
2589 */
31961943 2590static void mv_port_init(struct ata_ioports *port, void __iomem *port_mmio)
20f733e7 2591{
0d5ff566 2592 void __iomem *shd_base = port_mmio + SHD_BLK_OFS;
31961943
BR		 2593 unsigned serr_ofs;
2594
8b260248 2595 /* PIO related setup
31961943
BR		 2596 */
2597 port->data_addr = shd_base + (sizeof(u32) * ATA_REG_DATA);
8b260248 2598 port->error_addr =
31961943
BR		 2599 port->feature_addr = shd_base + (sizeof(u32) * ATA_REG_ERR);
2600 port->nsect_addr = shd_base + (sizeof(u32) * ATA_REG_NSECT);
2601 port->lbal_addr = shd_base + (sizeof(u32) * ATA_REG_LBAL);
2602 port->lbam_addr = shd_base + (sizeof(u32) * ATA_REG_LBAM);
2603 port->lbah_addr = shd_base + (sizeof(u32) * ATA_REG_LBAH);
2604 port->device_addr = shd_base + (sizeof(u32) * ATA_REG_DEVICE);
8b260248 2605 port->status_addr =
31961943
BR		 2606 port->command_addr = shd_base + (sizeof(u32) * ATA_REG_STATUS);
2607 /* special case: control/altstatus doesn't have ATA_REG_ address */
2608 port->altstatus_addr = port->ctl_addr = shd_base + SHD_CTL_AST_OFS;
2609
2610 /* unused: */
8d9db2d2 2611 port->cmd_addr = port->bmdma_addr = port->scr_addr = NULL;
20f733e7 2612
31961943
BR		 2613 /* Clear any currently outstanding port interrupt conditions */
2614 serr_ofs = mv_scr_offset(SCR_ERROR);
2615 writelfl(readl(port_mmio + serr_ofs), port_mmio + serr_ofs);
2616 writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2617
646a4da5
ML		 2618 /* unmask all non-transient EDMA error interrupts */
2619 writelfl(~EDMA_ERR_IRQ_TRANSIENT, port_mmio + EDMA_ERR_IRQ_MASK_OFS);
20f733e7 2620
8b260248 2621 VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n",
31961943
BR		 2622 readl(port_mmio + EDMA_CFG_OFS),
2623 readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS),
2624 readl(port_mmio + EDMA_ERR_IRQ_MASK_OFS));
20f733e7
BR		 2625}
2626
4447d351 2627static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
bca1c4eb 2628{
4447d351
TH		 2629 struct pci_dev *pdev = to_pci_dev(host->dev);
2630 struct mv_host_priv *hpriv = host->private_data;
bca1c4eb
JG		 2631 u32 hp_flags = hpriv->hp_flags;
2632
5796d1c4 2633 switch (board_idx) {
47c2b677
JG		 2634 case chip_5080:
2635 hpriv->ops = &mv5xxx_ops;
ee9ccdf7 2636 hp_flags |= MV_HP_GEN_I;
47c2b677 2637
44c10138 2638 switch (pdev->revision) {
47c2b677
JG		 2639 case 0x1:
2640 hp_flags |= MV_HP_ERRATA_50XXB0;
2641 break;
2642 case 0x3:
2643 hp_flags |= MV_HP_ERRATA_50XXB2;
2644 break;
2645 default:
2646 dev_printk(KERN_WARNING, &pdev->dev,
2647 "Applying 50XXB2 workarounds to unknown rev\n");
2648 hp_flags |= MV_HP_ERRATA_50XXB2;
2649 break;
2650 }
2651 break;
2652
bca1c4eb
JG		 2653 case chip_504x:
2654 case chip_508x:
47c2b677 2655 hpriv->ops = &mv5xxx_ops;
ee9ccdf7 2656 hp_flags |= MV_HP_GEN_I;
bca1c4eb 2657
44c10138 2658 switch (pdev->revision) {
47c2b677
JG		 2659 case 0x0:
2660 hp_flags |= MV_HP_ERRATA_50XXB0;
2661 break;
2662 case 0x3:
2663 hp_flags |= MV_HP_ERRATA_50XXB2;
2664 break;
2665 default:
2666 dev_printk(KERN_WARNING, &pdev->dev,
2667 "Applying B2 workarounds to unknown rev\n");
2668 hp_flags |= MV_HP_ERRATA_50XXB2;
2669 break;
bca1c4eb
JG		 2670 }
2671 break;
2672
2673 case chip_604x:
2674 case chip_608x:
47c2b677 2675 hpriv->ops = &mv6xxx_ops;
ee9ccdf7 2676 hp_flags |= MV_HP_GEN_II;
47c2b677 2677
44c10138 2678 switch (pdev->revision) {
47c2b677
JG		 2679 case 0x7:
2680 hp_flags |= MV_HP_ERRATA_60X1B2;
2681 break;
2682 case 0x9:
2683 hp_flags |= MV_HP_ERRATA_60X1C0;
bca1c4eb
JG		 2684 break;
2685 default:
2686 dev_printk(KERN_WARNING, &pdev->dev,
47c2b677
JG		 2687 "Applying B2 workarounds to unknown rev\n");
2688 hp_flags |= MV_HP_ERRATA_60X1B2;
bca1c4eb
JG		 2689 break;
2690 }
2691 break;
2692
e4e7b892 2693 case chip_7042:
02a121da 2694 hp_flags |= MV_HP_PCIE;
306b30f7
ML		 2695 if (pdev->vendor == PCI_VENDOR_ID_TTI &&
2696 (pdev->device == 0x2300 || pdev->device == 0x2310))
2697 {
4e520033
ML		 2698 /*
2699 * Highpoint RocketRAID PCIe 23xx series cards:
2700 *
2701 * Unconfigured drives are treated as "Legacy"
2702 * by the BIOS, and it overwrites sector 8 with
2703 * a "Lgcy" metadata block prior to Linux boot.
2704 *
2705 * Configured drives (RAID or JBOD) leave sector 8
2706 * alone, but instead overwrite a high numbered
2707 * sector for the RAID metadata. This sector can
2708 * be determined exactly, by truncating the physical
2709 * drive capacity to a nice even GB value.
2710 *
2711 * RAID metadata is at: (dev->n_sectors & ~0xfffff)
2712 *
2713 * Warn the user, lest they think we're just buggy.
2714 */
2715 printk(KERN_WARNING DRV_NAME ": Highpoint RocketRAID"
2716 " BIOS CORRUPTS DATA on all attached drives,"
2717 " regardless of if/how they are configured."
2718 " BEWARE!\n");
2719 printk(KERN_WARNING DRV_NAME ": For data safety, do not"
2720 " use sectors 8-9 on \"Legacy\" drives,"
2721 " and avoid the final two gigabytes on"
2722 " all RocketRAID BIOS initialized drives.\n");
306b30f7 2723 }
e4e7b892
JG		 2724 case chip_6042:
2725 hpriv->ops = &mv6xxx_ops;
e4e7b892
JG		 2726 hp_flags |= MV_HP_GEN_IIE;
2727
44c10138 2728 switch (pdev->revision) {
e4e7b892
JG		 2729 case 0x0:
2730 hp_flags |= MV_HP_ERRATA_XX42A0;
2731 break;
2732 case 0x1:
2733 hp_flags |= MV_HP_ERRATA_60X1C0;
2734 break;
2735 default:
2736 dev_printk(KERN_WARNING, &pdev->dev,
2737 "Applying 60X1C0 workarounds to unknown rev\n");
2738 hp_flags |= MV_HP_ERRATA_60X1C0;
2739 break;
2740 }
2741 break;
f351b2d6
SB		 2742 case chip_soc:
2743 hpriv->ops = &mv_soc_ops;
2744 hp_flags |= MV_HP_ERRATA_60X1C0;
2745 break;
e4e7b892 2746
bca1c4eb 2747 default:
f351b2d6 2748 dev_printk(KERN_ERR, host->dev,
5796d1c4 2749 "BUG: invalid board index %u\n", board_idx);
bca1c4eb
JG		 2750 return 1;
2751 }
2752
2753 hpriv->hp_flags = hp_flags;
02a121da
ML		 2754 if (hp_flags & MV_HP_PCIE) {
2755 hpriv->irq_cause_ofs = PCIE_IRQ_CAUSE_OFS;
2756 hpriv->irq_mask_ofs = PCIE_IRQ_MASK_OFS;
2757 hpriv->unmask_all_irqs = PCIE_UNMASK_ALL_IRQS;
2758 } else {
2759 hpriv->irq_cause_ofs = PCI_IRQ_CAUSE_OFS;
2760 hpriv->irq_mask_ofs = PCI_IRQ_MASK_OFS;
2761 hpriv->unmask_all_irqs = PCI_UNMASK_ALL_IRQS;
2762 }
bca1c4eb
JG		 2763
2764 return 0;
2765}
2766
05b308e1 2767/**
47c2b677 2768 * mv_init_host - Perform some early initialization of the host.
4447d351
TH		 2769 * @host: ATA host to initialize
2770 * @board_idx: controller index
05b308e1
BR		 2771 *
2772 * If possible, do an early global reset of the host. Then do
2773 * our port init and clear/unmask all/relevant host interrupts.
2774 *
2775 * LOCKING:
2776 * Inherited from caller.
2777 */
4447d351 2778static int mv_init_host(struct ata_host *host, unsigned int board_idx)
20f733e7
BR		 2779{
2780 int rc = 0, n_hc, port, hc;
4447d351 2781 struct mv_host_priv *hpriv = host->private_data;
f351b2d6 2782 void __iomem *mmio = hpriv->base;
47c2b677 2783
4447d351 2784 rc = mv_chip_id(host, board_idx);
bca1c4eb 2785 if (rc)
f351b2d6
SB		 2786 goto done;
2787
2788 if (HAS_PCI(host)) {
2789 hpriv->main_cause_reg_addr = hpriv->base +
2790 HC_MAIN_IRQ_CAUSE_OFS;
2791 hpriv->main_mask_reg_addr = hpriv->base + HC_MAIN_IRQ_MASK_OFS;
2792 } else {
2793 hpriv->main_cause_reg_addr = hpriv->base +
2794 HC_SOC_MAIN_IRQ_CAUSE_OFS;
2795 hpriv->main_mask_reg_addr = hpriv->base +
2796 HC_SOC_MAIN_IRQ_MASK_OFS;
2797 }
2798 /* global interrupt mask */
2799 writel(0, hpriv->main_mask_reg_addr);
bca1c4eb 2800
4447d351 2801 n_hc = mv_get_hc_count(host->ports[0]->flags);
bca1c4eb 2802
4447d351 2803 for (port = 0; port < host->n_ports; port++)
47c2b677 2804 hpriv->ops->read_preamp(hpriv, port, mmio);
20f733e7 2805
c9d39130 2806 rc = hpriv->ops->reset_hc(hpriv, mmio, n_hc);
47c2b677 2807 if (rc)
20f733e7 2808 goto done;
20f733e7 2809
522479fb 2810 hpriv->ops->reset_flash(hpriv, mmio);
7bb3c529 2811 hpriv->ops->reset_bus(host, mmio);
47c2b677 2812 hpriv->ops->enable_leds(hpriv, mmio);
20f733e7 2813
4447d351 2814 for (port = 0; port < host->n_ports; port++) {
ee9ccdf7 2815 if (IS_GEN_II(hpriv)) {
c9d39130
JG		 2816 void __iomem *port_mmio = mv_port_base(mmio, port);
2817
2a47ce06 2818 u32 ifctl = readl(port_mmio + SATA_INTERFACE_CTL);
eb46d684
ML		 2819 ifctl |= (1 << 7); /* enable gen2i speed */
2820 ifctl = (ifctl & 0xfff) | 0x9b1000; /* from chip spec */
2a47ce06
JG		 2821 writelfl(ifctl, port_mmio + SATA_INTERFACE_CTL);
2822 }
2823
c9d39130 2824 hpriv->ops->phy_errata(hpriv, mmio, port);
2a47ce06
JG		 2825 }
2826
4447d351 2827 for (port = 0; port < host->n_ports; port++) {
cbcdd875 2828 struct ata_port *ap = host->ports[port];
2a47ce06 2829 void __iomem *port_mmio = mv_port_base(mmio, port);
cbcdd875
TH		 2830
2831 mv_port_init(&ap->ioaddr, port_mmio);
2832
7bb3c529 2833#ifdef CONFIG_PCI
f351b2d6
SB		 2834 if (HAS_PCI(host)) {
2835 unsigned int offset = port_mmio - mmio;
2836 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, -1, "mmio");
2837 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, offset, "port");
2838 }
7bb3c529 2839#endif
20f733e7
BR		 2840 }
2841
2842 for (hc = 0; hc < n_hc; hc++) {
31961943
BR		 2843 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
2844
2845 VPRINTK("HC%i: HC config=0x%08x HC IRQ cause "
2846 "(before clear)=0x%08x\n", hc,
2847 readl(hc_mmio + HC_CFG_OFS),
2848 readl(hc_mmio + HC_IRQ_CAUSE_OFS));
2849
2850 /* Clear any currently outstanding hc interrupt conditions */
2851 writelfl(0, hc_mmio + HC_IRQ_CAUSE_OFS);
20f733e7
BR		 2852 }
2853
f351b2d6
SB		 2854 if (HAS_PCI(host)) {
2855 /* Clear any currently outstanding host interrupt conditions */
2856 writelfl(0, mmio + hpriv->irq_cause_ofs);
31961943 2857
f351b2d6
SB		 2858 /* and unmask interrupt generation for host regs */
2859 writelfl(hpriv->unmask_all_irqs, mmio + hpriv->irq_mask_ofs);
2860 if (IS_GEN_I(hpriv))
2861 writelfl(~HC_MAIN_MASKED_IRQS_5,
2862 hpriv->main_mask_reg_addr);
2863 else
2864 writelfl(~HC_MAIN_MASKED_IRQS,
2865 hpriv->main_mask_reg_addr);
2866
2867 VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x "
2868 "PCI int cause/mask=0x%08x/0x%08x\n",
2869 readl(hpriv->main_cause_reg_addr),
2870 readl(hpriv->main_mask_reg_addr),
2871 readl(mmio + hpriv->irq_cause_ofs),
2872 readl(mmio + hpriv->irq_mask_ofs));
2873 } else {
2874 writelfl(~HC_MAIN_MASKED_IRQS_SOC,
2875 hpriv->main_mask_reg_addr);
2876 VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x\n",
2877 readl(hpriv->main_cause_reg_addr),
2878 readl(hpriv->main_mask_reg_addr));
2879 }
2880done:
2881 return rc;
2882}
fb621e2f 2883
fbf14e2f
BB		 2884static int mv_create_dma_pools(struct mv_host_priv *hpriv, struct device *dev)
2885{
2886 hpriv->crqb_pool = dmam_pool_create("crqb_q", dev, MV_CRQB_Q_SZ,
2887 MV_CRQB_Q_SZ, 0);
2888 if (!hpriv->crqb_pool)
2889 return -ENOMEM;
2890
2891 hpriv->crpb_pool = dmam_pool_create("crpb_q", dev, MV_CRPB_Q_SZ,
2892 MV_CRPB_Q_SZ, 0);
2893 if (!hpriv->crpb_pool)
2894 return -ENOMEM;
2895
2896 hpriv->sg_tbl_pool = dmam_pool_create("sg_tbl", dev, MV_SG_TBL_SZ,
2897 MV_SG_TBL_SZ, 0);
2898 if (!hpriv->sg_tbl_pool)
2899 return -ENOMEM;
2900
2901 return 0;
2902}
2903
15a32632
LB		 2904static void mv_conf_mbus_windows(struct mv_host_priv *hpriv,
2905 struct mbus_dram_target_info *dram)
2906{
2907 int i;
2908
2909 for (i = 0; i < 4; i++) {
2910 writel(0, hpriv->base + WINDOW_CTRL(i));
2911 writel(0, hpriv->base + WINDOW_BASE(i));
2912 }
2913
2914 for (i = 0; i < dram->num_cs; i++) {
2915 struct mbus_dram_window *cs = dram->cs + i;
2916
2917 writel(((cs->size - 1) & 0xffff0000) |
2918 (cs->mbus_attr << 8) |
2919 (dram->mbus_dram_target_id << 4) | 1,
2920 hpriv->base + WINDOW_CTRL(i));
2921 writel(cs->base, hpriv->base + WINDOW_BASE(i));
2922 }
2923}
2924
f351b2d6
SB		 2925/**
2926 * mv_platform_probe - handle a positive probe of an soc Marvell
2927 * host
2928 * @pdev: platform device found
2929 *
2930 * LOCKING:
2931 * Inherited from caller.
2932 */
2933static int mv_platform_probe(struct platform_device *pdev)
2934{
2935 static int printed_version;
2936 const struct mv_sata_platform_data *mv_platform_data;
2937 const struct ata_port_info *ppi[] =
2938 { &mv_port_info[chip_soc], NULL };
2939 struct ata_host *host;
2940 struct mv_host_priv *hpriv;
2941 struct resource *res;
2942 int n_ports, rc;
20f733e7 2943
f351b2d6
SB		 2944 if (!printed_version++)
2945 dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
bca1c4eb 2946
f351b2d6
SB		 2947 /*
2948 * Simple resource validation ..
2949 */
2950 if (unlikely(pdev->num_resources != 2)) {
2951 dev_err(&pdev->dev, "invalid number of resources\n");
2952 return -EINVAL;
2953 }
2954
2955 /*
2956 * Get the register base first
2957 */
2958 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2959 if (res == NULL)
2960 return -EINVAL;
2961
2962 /* allocate host */
2963 mv_platform_data = pdev->dev.platform_data;
2964 n_ports = mv_platform_data->n_ports;
2965
2966 host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
2967 hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
2968
2969 if (!host || !hpriv)
2970 return -ENOMEM;
2971 host->private_data = hpriv;
2972 hpriv->n_ports = n_ports;
2973
2974 host->iomap = NULL;
f1cb0ea1
SB		 2975 hpriv->base = devm_ioremap(&pdev->dev, res->start,
2976 res->end - res->start + 1);
f351b2d6
SB		 2977 hpriv->base -= MV_SATAHC0_REG_BASE;
2978
15a32632
LB		 2979 /*
2980 * (Re-)program MBUS remapping windows if we are asked to.
2981 */
2982 if (mv_platform_data->dram != NULL)
2983 mv_conf_mbus_windows(hpriv, mv_platform_data->dram);
2984
fbf14e2f
BB		 2985 rc = mv_create_dma_pools(hpriv, &pdev->dev);
2986 if (rc)
2987 return rc;
2988
f351b2d6
SB		 2989 /* initialize adapter */
2990 rc = mv_init_host(host, chip_soc);
2991 if (rc)
2992 return rc;
2993
2994 dev_printk(KERN_INFO, &pdev->dev,
2995 "slots %u ports %d\n", (unsigned)MV_MAX_Q_DEPTH,
2996 host->n_ports);
2997
2998 return ata_host_activate(host, platform_get_irq(pdev, 0), mv_interrupt,
2999 IRQF_SHARED, &mv6_sht);
3000}
3001
3002/*
3003 *
3004 * mv_platform_remove - unplug a platform interface
3005 * @pdev: platform device
3006 *
3007 * A platform bus SATA device has been unplugged. Perform the needed
3008 * cleanup. Also called on module unload for any active devices.
3009 */
3010static int __devexit mv_platform_remove(struct platform_device *pdev)
3011{
3012 struct device *dev = &pdev->dev;
3013 struct ata_host *host = dev_get_drvdata(dev);
f351b2d6
SB		 3014
3015 ata_host_detach(host);
f351b2d6 3016 return 0;
20f733e7
BR		 3017}
3018
f351b2d6
SB		 3019static struct platform_driver mv_platform_driver = {
3020 .probe = mv_platform_probe,
3021 .remove = __devexit_p(mv_platform_remove),
3022 .driver = {
3023 .name = DRV_NAME,
3024 .owner = THIS_MODULE,
3025 },
3026};
3027
3028
7bb3c529 3029#ifdef CONFIG_PCI
f351b2d6
SB		 3030static int mv_pci_init_one(struct pci_dev *pdev,
3031 const struct pci_device_id *ent);
3032
7bb3c529
SB		 3033
3034static struct pci_driver mv_pci_driver = {
3035 .name = DRV_NAME,
3036 .id_table = mv_pci_tbl,
f351b2d6 3037 .probe = mv_pci_init_one,
7bb3c529
SB		 3038 .remove = ata_pci_remove_one,
3039};
3040
3041/*
3042 * module options
3043 */
3044static int msi; /* Use PCI msi; either zero (off, default) or non-zero */
3045
3046
3047/* move to PCI layer or libata core? */
3048static int pci_go_64(struct pci_dev *pdev)
3049{
3050 int rc;
3051
3052 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
3053 rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
3054 if (rc) {
3055 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
3056 if (rc) {
3057 dev_printk(KERN_ERR, &pdev->dev,
3058 "64-bit DMA enable failed\n");
3059 return rc;
3060 }
3061 }
3062 } else {
3063 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
3064 if (rc) {
3065 dev_printk(KERN_ERR, &pdev->dev,
3066 "32-bit DMA enable failed\n");
3067 return rc;
3068 }
3069 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
3070 if (rc) {
3071 dev_printk(KERN_ERR, &pdev->dev,
3072 "32-bit consistent DMA enable failed\n");
3073 return rc;
3074 }
3075 }
3076
3077 return rc;
3078}
3079
05b308e1
BR		 3080/**
3081 * mv_print_info - Dump key info to kernel log for perusal.
4447d351 3082 * @host: ATA host to print info about
05b308e1
BR		 3083 *
3084 * FIXME: complete this.
3085 *
3086 * LOCKING:
3087 * Inherited from caller.
3088 */
4447d351 3089static void mv_print_info(struct ata_host *host)
31961943 3090{
4447d351
TH		 3091 struct pci_dev *pdev = to_pci_dev(host->dev);
3092 struct mv_host_priv *hpriv = host->private_data;
44c10138 3093 u8 scc;
c1e4fe71 3094 const char *scc_s, *gen;
31961943
BR		 3095
3096 /* Use this to determine the HW stepping of the chip so we know
3097 * what errata to workaround
3098 */
31961943
BR		 3099 pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &scc);
3100 if (scc == 0)
3101 scc_s = "SCSI";
3102 else if (scc == 0x01)
3103 scc_s = "RAID";
3104 else
c1e4fe71
JG		 3105 scc_s = "?";
3106
3107 if (IS_GEN_I(hpriv))
3108 gen = "I";
3109 else if (IS_GEN_II(hpriv))
3110 gen = "II";
3111 else if (IS_GEN_IIE(hpriv))
3112 gen = "IIE";
3113 else
3114 gen = "?";
31961943 3115
a9524a76 3116 dev_printk(KERN_INFO, &pdev->dev,
c1e4fe71
JG		 3117 "Gen-%s %u slots %u ports %s mode IRQ via %s\n",
3118 gen, (unsigned)MV_MAX_Q_DEPTH, host->n_ports,
31961943
BR		 3119 scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
3120}
3121
05b308e1 3122/**
f351b2d6 3123 * mv_pci_init_one - handle a positive probe of a PCI Marvell host
05b308e1
BR		 3124 * @pdev: PCI device found
3125 * @ent: PCI device ID entry for the matched host
3126 *
3127 * LOCKING:
3128 * Inherited from caller.
3129 */
f351b2d6
SB		 3130static int mv_pci_init_one(struct pci_dev *pdev,
3131 const struct pci_device_id *ent)
20f733e7 3132{
2dcb407e 3133 static int printed_version;
20f733e7 3134 unsigned int board_idx = (unsigned int)ent->driver_data;
4447d351
TH		 3135 const struct ata_port_info *ppi[] = { &mv_port_info[board_idx], NULL };
3136 struct ata_host *host;
3137 struct mv_host_priv *hpriv;
3138 int n_ports, rc;
20f733e7 3139
a9524a76
JG		 3140 if (!printed_version++)
3141 dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
20f733e7 3142
4447d351
TH		 3143 /* allocate host */
3144 n_ports = mv_get_hc_count(ppi[0]->flags) * MV_PORTS_PER_HC;
3145
3146 host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
3147 hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
3148 if (!host || !hpriv)
3149 return -ENOMEM;
3150 host->private_data = hpriv;
f351b2d6 3151 hpriv->n_ports = n_ports;
4447d351
TH		 3152
3153 /* acquire resources */
24dc5f33
TH		 3154 rc = pcim_enable_device(pdev);
3155 if (rc)
20f733e7 3156 return rc;
20f733e7 3157
0d5ff566
TH		 3158 rc = pcim_iomap_regions(pdev, 1 << MV_PRIMARY_BAR, DRV_NAME);
3159 if (rc == -EBUSY)
24dc5f33 3160 pcim_pin_device(pdev);
0d5ff566 3161 if (rc)
24dc5f33 3162 return rc;
4447d351 3163 host->iomap = pcim_iomap_table(pdev);
f351b2d6 3164 hpriv->base = host->iomap[MV_PRIMARY_BAR];
20f733e7 3165
d88184fb
JG		 3166 rc = pci_go_64(pdev);
3167 if (rc)
3168 return rc;
3169
da2fa9ba
ML		 3170 rc = mv_create_dma_pools(hpriv, &pdev->dev);
3171 if (rc)
3172 return rc;
3173
20f733e7 3174 /* initialize adapter */
4447d351 3175 rc = mv_init_host(host, board_idx);
24dc5f33
TH		 3176 if (rc)
3177 return rc;
20f733e7 3178
31961943 3179 /* Enable interrupts */
6a59dcf8 3180 if (msi && pci_enable_msi(pdev))
31961943 3181 pci_intx(pdev, 1);
20f733e7 3182
31961943 3183 mv_dump_pci_cfg(pdev, 0x68);
4447d351 3184 mv_print_info(host);
20f733e7 3185
4447d351 3186 pci_set_master(pdev);
ea8b4db9 3187 pci_try_set_mwi(pdev);
4447d351 3188 return ata_host_activate(host, pdev->irq, mv_interrupt, IRQF_SHARED,
c5d3e45a 3189 IS_GEN_I(hpriv) ? &mv5_sht : &mv6_sht);
20f733e7 3190}
7bb3c529 3191#endif
20f733e7 3192
f351b2d6
SB		 3193static int mv_platform_probe(struct platform_device *pdev);
3194static int __devexit mv_platform_remove(struct platform_device *pdev);
3195
20f733e7
BR		 3196static int __init mv_init(void)
3197{
7bb3c529
SB		 3198 int rc = -ENODEV;
3199#ifdef CONFIG_PCI
3200 rc = pci_register_driver(&mv_pci_driver);
f351b2d6
SB		 3201 if (rc < 0)
3202 return rc;
3203#endif
3204 rc = platform_driver_register(&mv_platform_driver);
3205
3206#ifdef CONFIG_PCI
3207 if (rc < 0)
3208 pci_unregister_driver(&mv_pci_driver);
7bb3c529
SB		 3209#endif
3210 return rc;
20f733e7
BR		 3211}
3212
3213static void __exit mv_exit(void)
3214{
7bb3c529 3215#ifdef CONFIG_PCI
20f733e7 3216 pci_unregister_driver(&mv_pci_driver);
7bb3c529 3217#endif
f351b2d6 3218 platform_driver_unregister(&mv_platform_driver);
20f733e7
BR		 3219}
3220
3221MODULE_AUTHOR("Brett Russ");
3222MODULE_DESCRIPTION("SCSI low-level driver for Marvell SATA controllers");
3223MODULE_LICENSE("GPL");
3224MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
3225MODULE_VERSION(DRV_VERSION);
2e7e1214 3226MODULE_ALIAS("platform:sata_mv");
20f733e7 3227
7bb3c529 3228#ifdef CONFIG_PCI
ddef9bb3
JG		 3229module_param(msi, int, 0444);
3230MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
7bb3c529 3231#endif
ddef9bb3 3232
20f733e7
BR		 3233module_init(mv_init);
3234module_exit(mv_exit);
Linux kernel - Deliverables
This page took 0.613393 seconds and 5 git commands to generate.