?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ath5k: fix values for bus error bits in ISR2
[linux-2.6/next.git] / drivers / ata / sata_nv.c
blobb2d11f300c39045a8ce645949409fde0dc1a971c
1 /*
2 * sata_nv.c - NVIDIA nForce SATA
3 *
4 * Copyright 2004 NVIDIA Corp. All rights reserved.
5 * Copyright 2004 Andrew Chew
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2, or (at your option)
11 * any later version.
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; see the file COPYING. If not, write to
20 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 *
23 * libata documentation is available via 'make {ps|pdf}docs',
24 * as Documentation/DocBook/libata.*
25 *
26 * No hardware documentation available outside of NVIDIA.
27 * This driver programs the NVIDIA SATA controller in a similar
28 * fashion as with other PCI IDE BMDMA controllers, with a few
29 * NV-specific details such as register offsets, SATA phy location,
30 * hotplug info, etc.
31 *
32 * CK804/MCP04 controllers support an alternate programming interface
33 * similar to the ADMA specification (with some modifications).
34 * This allows the use of NCQ. Non-DMA-mapped ATA commands are still
35 * sent through the legacy interface.
36 *
37 */
38
39 #include <linux/kernel.h>
40 #include <linux/module.h>
41 #include <linux/pci.h>
42 #include <linux/init.h>
43 #include <linux/blkdev.h>
44 #include <linux/delay.h>
45 #include <linux/interrupt.h>
46 #include <linux/device.h>
47 #include <scsi/scsi_host.h>
48 #include <scsi/scsi_device.h>
49 #include <linux/libata.h>
50
51 #define DRV_NAME "sata_nv"
52 #define DRV_VERSION "3.5"
53
54 #define NV_ADMA_DMA_BOUNDARY 0xffffffffUL
55
56 enum {
57 NV_MMIO_BAR = 5,
58
59 NV_PORTS = 2,
60 NV_PIO_MASK = ATA_PIO4,
61 NV_MWDMA_MASK = ATA_MWDMA2,
62 NV_UDMA_MASK = ATA_UDMA6,
63 NV_PORT0_SCR_REG_OFFSET = 0x00,
64 NV_PORT1_SCR_REG_OFFSET = 0x40,
65
66 /* INT_STATUS/ENABLE */
67 NV_INT_STATUS = 0x10,
68 NV_INT_ENABLE = 0x11,
69 NV_INT_STATUS_CK804 = 0x440,
70 NV_INT_ENABLE_CK804 = 0x441,
71
72 /* INT_STATUS/ENABLE bits */
73 NV_INT_DEV = 0x01,
74 NV_INT_PM = 0x02,
75 NV_INT_ADDED = 0x04,
76 NV_INT_REMOVED = 0x08,
77
78 NV_INT_PORT_SHIFT = 4, /* each port occupies 4 bits */
79
80 NV_INT_ALL = 0x0f,
81 NV_INT_MASK = NV_INT_DEV |
82 NV_INT_ADDED | NV_INT_REMOVED,
83
84 /* INT_CONFIG */
85 NV_INT_CONFIG = 0x12,
86 NV_INT_CONFIG_METHD = 0x01, // 0 = INT, 1 = SMI
87
88 // For PCI config register 20
89 NV_MCP_SATA_CFG_20 = 0x50,
90 NV_MCP_SATA_CFG_20_SATA_SPACE_EN = 0x04,
91 NV_MCP_SATA_CFG_20_PORT0_EN = (1 << 17),
92 NV_MCP_SATA_CFG_20_PORT1_EN = (1 << 16),
93 NV_MCP_SATA_CFG_20_PORT0_PWB_EN = (1 << 14),
94 NV_MCP_SATA_CFG_20_PORT1_PWB_EN = (1 << 12),
95
96 NV_ADMA_MAX_CPBS = 32,
97 NV_ADMA_CPB_SZ = 128,
98 NV_ADMA_APRD_SZ = 16,
99 NV_ADMA_SGTBL_LEN = (1024 - NV_ADMA_CPB_SZ) /
100 NV_ADMA_APRD_SZ,
101 NV_ADMA_SGTBL_TOTAL_LEN = NV_ADMA_SGTBL_LEN + 5,
102 NV_ADMA_SGTBL_SZ = NV_ADMA_SGTBL_LEN * NV_ADMA_APRD_SZ,
103 NV_ADMA_PORT_PRIV_DMA_SZ = NV_ADMA_MAX_CPBS *
104 (NV_ADMA_CPB_SZ + NV_ADMA_SGTBL_SZ),
105
106 /* BAR5 offset to ADMA general registers */
107 NV_ADMA_GEN = 0x400,
108 NV_ADMA_GEN_CTL = 0x00,
109 NV_ADMA_NOTIFIER_CLEAR = 0x30,
110
111 /* BAR5 offset to ADMA ports */
112 NV_ADMA_PORT = 0x480,
113
114 /* size of ADMA port register space */
115 NV_ADMA_PORT_SIZE = 0x100,
116
117 /* ADMA port registers */
118 NV_ADMA_CTL = 0x40,
119 NV_ADMA_CPB_COUNT = 0x42,
120 NV_ADMA_NEXT_CPB_IDX = 0x43,
121 NV_ADMA_STAT = 0x44,
122 NV_ADMA_CPB_BASE_LOW = 0x48,
123 NV_ADMA_CPB_BASE_HIGH = 0x4C,
124 NV_ADMA_APPEND = 0x50,
125 NV_ADMA_NOTIFIER = 0x68,
126 NV_ADMA_NOTIFIER_ERROR = 0x6C,
127
128 /* NV_ADMA_CTL register bits */
129 NV_ADMA_CTL_HOTPLUG_IEN = (1 << 0),
130 NV_ADMA_CTL_CHANNEL_RESET = (1 << 5),
131 NV_ADMA_CTL_GO = (1 << 7),
132 NV_ADMA_CTL_AIEN = (1 << 8),
133 NV_ADMA_CTL_READ_NON_COHERENT = (1 << 11),
134 NV_ADMA_CTL_WRITE_NON_COHERENT = (1 << 12),
135
136 /* CPB response flag bits */
137 NV_CPB_RESP_DONE = (1 << 0),
138 NV_CPB_RESP_ATA_ERR = (1 << 3),
139 NV_CPB_RESP_CMD_ERR = (1 << 4),
140 NV_CPB_RESP_CPB_ERR = (1 << 7),
141
142 /* CPB control flag bits */
143 NV_CPB_CTL_CPB_VALID = (1 << 0),
144 NV_CPB_CTL_QUEUE = (1 << 1),
145 NV_CPB_CTL_APRD_VALID = (1 << 2),
146 NV_CPB_CTL_IEN = (1 << 3),
147 NV_CPB_CTL_FPDMA = (1 << 4),
148
149 /* APRD flags */
150 NV_APRD_WRITE = (1 << 1),
151 NV_APRD_END = (1 << 2),
152 NV_APRD_CONT = (1 << 3),
153
154 /* NV_ADMA_STAT flags */
155 NV_ADMA_STAT_TIMEOUT = (1 << 0),
156 NV_ADMA_STAT_HOTUNPLUG = (1 << 1),
157 NV_ADMA_STAT_HOTPLUG = (1 << 2),
158 NV_ADMA_STAT_CPBERR = (1 << 4),
159 NV_ADMA_STAT_SERROR = (1 << 5),
160 NV_ADMA_STAT_CMD_COMPLETE = (1 << 6),
161 NV_ADMA_STAT_IDLE = (1 << 8),
162 NV_ADMA_STAT_LEGACY = (1 << 9),
163 NV_ADMA_STAT_STOPPED = (1 << 10),
164 NV_ADMA_STAT_DONE = (1 << 12),
165 NV_ADMA_STAT_ERR = NV_ADMA_STAT_CPBERR |
166 NV_ADMA_STAT_TIMEOUT,
167
168 /* port flags */
169 NV_ADMA_PORT_REGISTER_MODE = (1 << 0),
170 NV_ADMA_ATAPI_SETUP_COMPLETE = (1 << 1),
171
172 /* MCP55 reg offset */
173 NV_CTL_MCP55 = 0x400,
174 NV_INT_STATUS_MCP55 = 0x440,
175 NV_INT_ENABLE_MCP55 = 0x444,
176 NV_NCQ_REG_MCP55 = 0x448,
177
178 /* MCP55 */
179 NV_INT_ALL_MCP55 = 0xffff,
180 NV_INT_PORT_SHIFT_MCP55 = 16, /* each port occupies 16 bits */
181 NV_INT_MASK_MCP55 = NV_INT_ALL_MCP55 & 0xfffd,
182
183 /* SWNCQ ENABLE BITS*/
184 NV_CTL_PRI_SWNCQ = 0x02,
185 NV_CTL_SEC_SWNCQ = 0x04,
186
187 /* SW NCQ status bits*/
188 NV_SWNCQ_IRQ_DEV = (1 << 0),
189 NV_SWNCQ_IRQ_PM = (1 << 1),
190 NV_SWNCQ_IRQ_ADDED = (1 << 2),
191 NV_SWNCQ_IRQ_REMOVED = (1 << 3),
192
193 NV_SWNCQ_IRQ_BACKOUT = (1 << 4),
194 NV_SWNCQ_IRQ_SDBFIS = (1 << 5),
195 NV_SWNCQ_IRQ_DHREGFIS = (1 << 6),
196 NV_SWNCQ_IRQ_DMASETUP = (1 << 7),
197
198 NV_SWNCQ_IRQ_HOTPLUG = NV_SWNCQ_IRQ_ADDED |
199 NV_SWNCQ_IRQ_REMOVED,
200
201 };
202
203 /* ADMA Physical Region Descriptor - one SG segment */
204 struct nv_adma_prd {
205 __le64 addr;
206 __le32 len;
207 u8 flags;
208 u8 packet_len;
209 __le16 reserved;
210 };
211
212 enum nv_adma_regbits {
213 CMDEND = (1 << 15), /* end of command list */
214 WNB = (1 << 14), /* wait-not-BSY */
215 IGN = (1 << 13), /* ignore this entry */
216 CS1n = (1 << (4 + 8)), /* std. PATA signals follow... */
217 DA2 = (1 << (2 + 8)),
218 DA1 = (1 << (1 + 8)),
219 DA0 = (1 << (0 + 8)),
220 };
221
222 /* ADMA Command Parameter Block
223 The first 5 SG segments are stored inside the Command Parameter Block itself.
224 If there are more than 5 segments the remainder are stored in a separate
225 memory area indicated by next_aprd. */
226 struct nv_adma_cpb {
227 u8 resp_flags; /* 0 */
228 u8 reserved1; /* 1 */
229 u8 ctl_flags; /* 2 */
230 /* len is length of taskfile in 64 bit words */
231 u8 len; /* 3 */
232 u8 tag; /* 4 */
233 u8 next_cpb_idx; /* 5 */
234 __le16 reserved2; /* 6-7 */
235 __le16 tf[12]; /* 8-31 */
236 struct nv_adma_prd aprd[5]; /* 32-111 */
237 __le64 next_aprd; /* 112-119 */
238 __le64 reserved3; /* 120-127 */
239 };
240
241
242 struct nv_adma_port_priv {
243 struct nv_adma_cpb *cpb;
244 dma_addr_t cpb_dma;
245 struct nv_adma_prd *aprd;
246 dma_addr_t aprd_dma;
247 void __iomem *ctl_block;
248 void __iomem *gen_block;
249 void __iomem *notifier_clear_block;
250 u64 adma_dma_mask;
251 u8 flags;
252 int last_issue_ncq;
253 };
254
255 struct nv_host_priv {
256 unsigned long type;
257 };
258
259 struct defer_queue {
260 u32 defer_bits;
261 unsigned int head;
262 unsigned int tail;
263 unsigned int tag[ATA_MAX_QUEUE];
264 };
265
266 enum ncq_saw_flag_list {
267 ncq_saw_d2h = (1U << 0),
268 ncq_saw_dmas = (1U << 1),
269 ncq_saw_sdb = (1U << 2),
270 ncq_saw_backout = (1U << 3),
271 };
272
273 struct nv_swncq_port_priv {
274 struct ata_prd *prd; /* our SG list */
275 dma_addr_t prd_dma; /* and its DMA mapping */
276 void __iomem *sactive_block;
277 void __iomem *irq_block;
278 void __iomem *tag_block;
279 u32 qc_active;
280
281 unsigned int last_issue_tag;
282
283 /* fifo circular queue to store deferral command */
284 struct defer_queue defer_queue;
285
286 /* for NCQ interrupt analysis */
287 u32 dhfis_bits;
288 u32 dmafis_bits;
289 u32 sdbfis_bits;
290
291 unsigned int ncq_flags;
292 };
293
294
295 #define NV_ADMA_CHECK_INTR(GCTL, PORT) ((GCTL) & (1 << (19 + (12 * (PORT)))))
296
297 static int nv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
298 #ifdef CONFIG_PM
299 static int nv_pci_device_resume(struct pci_dev *pdev);
300 #endif
301 static void nv_ck804_host_stop(struct ata_host *host);
302 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance);
303 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance);
304 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance);
305 static int nv_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
306 static int nv_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
307
308 static int nv_hardreset(struct ata_link *link, unsigned int *class,
309 unsigned long deadline);
310 static void nv_nf2_freeze(struct ata_port *ap);
311 static void nv_nf2_thaw(struct ata_port *ap);
312 static void nv_ck804_freeze(struct ata_port *ap);
313 static void nv_ck804_thaw(struct ata_port *ap);
314 static int nv_adma_slave_config(struct scsi_device *sdev);
315 static int nv_adma_check_atapi_dma(struct ata_queued_cmd *qc);
316 static void nv_adma_qc_prep(struct ata_queued_cmd *qc);
317 static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc);
318 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance);
319 static void nv_adma_irq_clear(struct ata_port *ap);
320 static int nv_adma_port_start(struct ata_port *ap);
321 static void nv_adma_port_stop(struct ata_port *ap);
322 #ifdef CONFIG_PM
323 static int nv_adma_port_suspend(struct ata_port *ap, pm_message_t mesg);
324 static int nv_adma_port_resume(struct ata_port *ap);
325 #endif
326 static void nv_adma_freeze(struct ata_port *ap);
327 static void nv_adma_thaw(struct ata_port *ap);
328 static void nv_adma_error_handler(struct ata_port *ap);
329 static void nv_adma_host_stop(struct ata_host *host);
330 static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc);
331 static void nv_adma_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
332
333 static void nv_mcp55_thaw(struct ata_port *ap);
334 static void nv_mcp55_freeze(struct ata_port *ap);
335 static void nv_swncq_error_handler(struct ata_port *ap);
336 static int nv_swncq_slave_config(struct scsi_device *sdev);
337 static int nv_swncq_port_start(struct ata_port *ap);
338 static void nv_swncq_qc_prep(struct ata_queued_cmd *qc);
339 static void nv_swncq_fill_sg(struct ata_queued_cmd *qc);
340 static unsigned int nv_swncq_qc_issue(struct ata_queued_cmd *qc);
341 static void nv_swncq_irq_clear(struct ata_port *ap, u16 fis);
342 static irqreturn_t nv_swncq_interrupt(int irq, void *dev_instance);
343 #ifdef CONFIG_PM
344 static int nv_swncq_port_suspend(struct ata_port *ap, pm_message_t mesg);
345 static int nv_swncq_port_resume(struct ata_port *ap);
346 #endif
347
348 enum nv_host_type
349 {
350 GENERIC,
351 NFORCE2,
352 NFORCE3 = NFORCE2, /* NF2 == NF3 as far as sata_nv is concerned */
353 CK804,
354 ADMA,
355 MCP5x,
356 SWNCQ,
357 };
358
359 static const struct pci_device_id nv_pci_tbl[] = {
360 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA), NFORCE2 },
361 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA), NFORCE3 },
362 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2), NFORCE3 },
363 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA), CK804 },
364 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2), CK804 },
365 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA), CK804 },
366 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2), CK804 },
367 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA), MCP5x },
368 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2), MCP5x },
369 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA), MCP5x },
370 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2), MCP5x },
371 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA), GENERIC },
372 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2), GENERIC },
373 { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3), GENERIC },
374
375 { } /* terminate list */
376 };
377
378 static struct pci_driver nv_pci_driver = {
379 .name = DRV_NAME,
380 .id_table = nv_pci_tbl,
381 .probe = nv_init_one,
382 #ifdef CONFIG_PM
383 .suspend = ata_pci_device_suspend,
384 .resume = nv_pci_device_resume,
385 #endif
386 .remove = ata_pci_remove_one,
387 };
388
389 static struct scsi_host_template nv_sht = {
390 ATA_BMDMA_SHT(DRV_NAME),
391 };
392
393 static struct scsi_host_template nv_adma_sht = {
394 ATA_NCQ_SHT(DRV_NAME),
395 .can_queue = NV_ADMA_MAX_CPBS,
396 .sg_tablesize = NV_ADMA_SGTBL_TOTAL_LEN,
397 .dma_boundary = NV_ADMA_DMA_BOUNDARY,
398 .slave_configure = nv_adma_slave_config,
399 };
400
401 static struct scsi_host_template nv_swncq_sht = {
402 ATA_NCQ_SHT(DRV_NAME),
403 .can_queue = ATA_MAX_QUEUE,
404 .sg_tablesize = LIBATA_MAX_PRD,
405 .dma_boundary = ATA_DMA_BOUNDARY,
406 .slave_configure = nv_swncq_slave_config,
407 };
408
409 /*
410 * NV SATA controllers have various different problems with hardreset
411 * protocol depending on the specific controller and device.
412 *
413 * GENERIC:
414 *
415 * bko11195 reports that link doesn't come online after hardreset on
416 * generic nv's and there have been several other similar reports on
417 * linux-ide.
418 *
419 * bko12351#c23 reports that warmplug on MCP61 doesn't work with
420 * softreset.
421 *
422 * NF2/3:
423 *
424 * bko3352 reports nf2/3 controllers can't determine device signature
425 * reliably after hardreset. The following thread reports detection
426 * failure on cold boot with the standard debouncing timing.
427 *
428 * http://thread.gmane.org/gmane.linux.ide/34098
429 *
430 * bko12176 reports that hardreset fails to bring up the link during
431 * boot on nf2.
432 *
433 * CK804:
434 *
435 * For initial probing after boot and hot plugging, hardreset mostly
436 * works fine on CK804 but curiously, reprobing on the initial port
437 * by rescanning or rmmod/insmod fails to acquire the initial D2H Reg
438 * FIS in somewhat undeterministic way.
439 *
440 * SWNCQ:
441 *
442 * bko12351 reports that when SWNCQ is enabled, for hotplug to work,
443 * hardreset should be used and hardreset can't report proper
444 * signature, which suggests that mcp5x is closer to nf2 as long as
445 * reset quirkiness is concerned.
446 *
447 * bko12703 reports that boot probing fails for intel SSD with
448 * hardreset. Link fails to come online. Softreset works fine.
449 *
450 * The failures are varied but the following patterns seem true for
451 * all flavors.
452 *
453 * - Softreset during boot always works.
454 *
455 * - Hardreset during boot sometimes fails to bring up the link on
456 * certain comibnations and device signature acquisition is
457 * unreliable.
458 *
459 * - Hardreset is often necessary after hotplug.
460 *
461 * So, preferring softreset for boot probing and error handling (as
462 * hardreset might bring down the link) but using hardreset for
463 * post-boot probing should work around the above issues in most
464 * cases. Define nv_hardreset() which only kicks in for post-boot
465 * probing and use it for all variants.
466 */
467 static struct ata_port_operations nv_generic_ops = {
468 .inherits = &ata_bmdma_port_ops,
469 .lost_interrupt = ATA_OP_NULL,
470 .scr_read = nv_scr_read,
471 .scr_write = nv_scr_write,
472 .hardreset = nv_hardreset,
473 };
474
475 static struct ata_port_operations nv_nf2_ops = {
476 .inherits = &nv_generic_ops,
477 .freeze = nv_nf2_freeze,
478 .thaw = nv_nf2_thaw,
479 };
480
481 static struct ata_port_operations nv_ck804_ops = {
482 .inherits = &nv_generic_ops,
483 .freeze = nv_ck804_freeze,
484 .thaw = nv_ck804_thaw,
485 .host_stop = nv_ck804_host_stop,
486 };
487
488 static struct ata_port_operations nv_adma_ops = {
489 .inherits = &nv_ck804_ops,
490
491 .check_atapi_dma = nv_adma_check_atapi_dma,
492 .sff_tf_read = nv_adma_tf_read,
493 .qc_defer = ata_std_qc_defer,
494 .qc_prep = nv_adma_qc_prep,
495 .qc_issue = nv_adma_qc_issue,
496 .sff_irq_clear = nv_adma_irq_clear,
497
498 .freeze = nv_adma_freeze,
499 .thaw = nv_adma_thaw,
500 .error_handler = nv_adma_error_handler,
501 .post_internal_cmd = nv_adma_post_internal_cmd,
502
503 .port_start = nv_adma_port_start,
504 .port_stop = nv_adma_port_stop,
505 #ifdef CONFIG_PM
506 .port_suspend = nv_adma_port_suspend,
507 .port_resume = nv_adma_port_resume,
508 #endif
509 .host_stop = nv_adma_host_stop,
510 };
511
512 static struct ata_port_operations nv_swncq_ops = {
513 .inherits = &nv_generic_ops,
514
515 .qc_defer = ata_std_qc_defer,
516 .qc_prep = nv_swncq_qc_prep,
517 .qc_issue = nv_swncq_qc_issue,
518
519 .freeze = nv_mcp55_freeze,
520 .thaw = nv_mcp55_thaw,
521 .error_handler = nv_swncq_error_handler,
522
523 #ifdef CONFIG_PM
524 .port_suspend = nv_swncq_port_suspend,
525 .port_resume = nv_swncq_port_resume,
526 #endif
527 .port_start = nv_swncq_port_start,
528 };
529
530 struct nv_pi_priv {
531 irq_handler_t irq_handler;
532 struct scsi_host_template *sht;
533 };
534
535 #define NV_PI_PRIV(_irq_handler, _sht) \
536 &(struct nv_pi_priv){ .irq_handler = _irq_handler, .sht = _sht }
537
538 static const struct ata_port_info nv_port_info[] = {
539 /* generic */
540 {
541 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
542 .pio_mask = NV_PIO_MASK,
543 .mwdma_mask = NV_MWDMA_MASK,
544 .udma_mask = NV_UDMA_MASK,
545 .port_ops = &nv_generic_ops,
546 .private_data = NV_PI_PRIV(nv_generic_interrupt, &nv_sht),
547 },
548 /* nforce2/3 */
549 {
550 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
551 .pio_mask = NV_PIO_MASK,
552 .mwdma_mask = NV_MWDMA_MASK,
553 .udma_mask = NV_UDMA_MASK,
554 .port_ops = &nv_nf2_ops,
555 .private_data = NV_PI_PRIV(nv_nf2_interrupt, &nv_sht),
556 },
557 /* ck804 */
558 {
559 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
560 .pio_mask = NV_PIO_MASK,
561 .mwdma_mask = NV_MWDMA_MASK,
562 .udma_mask = NV_UDMA_MASK,
563 .port_ops = &nv_ck804_ops,
564 .private_data = NV_PI_PRIV(nv_ck804_interrupt, &nv_sht),
565 },
566 /* ADMA */
567 {
568 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
569 ATA_FLAG_MMIO | ATA_FLAG_NCQ,
570 .pio_mask = NV_PIO_MASK,
571 .mwdma_mask = NV_MWDMA_MASK,
572 .udma_mask = NV_UDMA_MASK,
573 .port_ops = &nv_adma_ops,
574 .private_data = NV_PI_PRIV(nv_adma_interrupt, &nv_adma_sht),
575 },
576 /* MCP5x */
577 {
578 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
579 .pio_mask = NV_PIO_MASK,
580 .mwdma_mask = NV_MWDMA_MASK,
581 .udma_mask = NV_UDMA_MASK,
582 .port_ops = &nv_generic_ops,
583 .private_data = NV_PI_PRIV(nv_generic_interrupt, &nv_sht),
584 },
585 /* SWNCQ */
586 {
587 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
588 ATA_FLAG_NCQ,
589 .pio_mask = NV_PIO_MASK,
590 .mwdma_mask = NV_MWDMA_MASK,
591 .udma_mask = NV_UDMA_MASK,
592 .port_ops = &nv_swncq_ops,
593 .private_data = NV_PI_PRIV(nv_swncq_interrupt, &nv_swncq_sht),
594 },
595 };
596
597 MODULE_AUTHOR("NVIDIA");
598 MODULE_DESCRIPTION("low-level driver for NVIDIA nForce SATA controller");
599 MODULE_LICENSE("GPL");
600 MODULE_DEVICE_TABLE(pci, nv_pci_tbl);
601 MODULE_VERSION(DRV_VERSION);
602
603 static int adma_enabled;
604 static int swncq_enabled = 1;
605
606 static void nv_adma_register_mode(struct ata_port *ap)
607 {
608 struct nv_adma_port_priv *pp = ap->private_data;
609 void __iomem *mmio = pp->ctl_block;
610 u16 tmp, status;
611 int count = 0;
612
613 if (pp->flags & NV_ADMA_PORT_REGISTER_MODE)
614 return;
615
616 status = readw(mmio + NV_ADMA_STAT);
617 while (!(status & NV_ADMA_STAT_IDLE) && count < 20) {
618 ndelay(50);
619 status = readw(mmio + NV_ADMA_STAT);
620 count++;
621 }
622 if (count == 20)
623 ata_port_printk(ap, KERN_WARNING,
624 "timeout waiting for ADMA IDLE, stat=0x%hx\n",
625 status);
626
627 tmp = readw(mmio + NV_ADMA_CTL);
628 writew(tmp & ~NV_ADMA_CTL_GO, mmio + NV_ADMA_CTL);
629
630 count = 0;
631 status = readw(mmio + NV_ADMA_STAT);
632 while (!(status & NV_ADMA_STAT_LEGACY) && count < 20) {
633 ndelay(50);
634 status = readw(mmio + NV_ADMA_STAT);
635 count++;
636 }
637 if (count == 20)
638 ata_port_printk(ap, KERN_WARNING,
639 "timeout waiting for ADMA LEGACY, stat=0x%hx\n",
640 status);
641
642 pp->flags |= NV_ADMA_PORT_REGISTER_MODE;
643 }
644
645 static void nv_adma_mode(struct ata_port *ap)
646 {
647 struct nv_adma_port_priv *pp = ap->private_data;
648 void __iomem *mmio = pp->ctl_block;
649 u16 tmp, status;
650 int count = 0;
651
652 if (!(pp->flags & NV_ADMA_PORT_REGISTER_MODE))
653 return;
654
655 WARN_ON(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE);
656
657 tmp = readw(mmio + NV_ADMA_CTL);
658 writew(tmp | NV_ADMA_CTL_GO, mmio + NV_ADMA_CTL);
659
660 status = readw(mmio + NV_ADMA_STAT);
661 while (((status & NV_ADMA_STAT_LEGACY) ||
662 !(status & NV_ADMA_STAT_IDLE)) && count < 20) {
663 ndelay(50);
664 status = readw(mmio + NV_ADMA_STAT);
665 count++;
666 }
667 if (count == 20)
668 ata_port_printk(ap, KERN_WARNING,
669 "timeout waiting for ADMA LEGACY clear and IDLE, stat=0x%hx\n",
670 status);
671
672 pp->flags &= ~NV_ADMA_PORT_REGISTER_MODE;
673 }
674
675 static int nv_adma_slave_config(struct scsi_device *sdev)
676 {
677 struct ata_port *ap = ata_shost_to_port(sdev->host);
678 struct nv_adma_port_priv *pp = ap->private_data;
679 struct nv_adma_port_priv *port0, *port1;
680 struct scsi_device *sdev0, *sdev1;
681 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
682 unsigned long segment_boundary, flags;
683 unsigned short sg_tablesize;
684 int rc;
685 int adma_enable;
686 u32 current_reg, new_reg, config_mask;
687
688 rc = ata_scsi_slave_config(sdev);
689
690 if (sdev->id >= ATA_MAX_DEVICES || sdev->channel || sdev->lun)
691 /* Not a proper libata device, ignore */
692 return rc;
693
694 spin_lock_irqsave(ap->lock, flags);
695
696 if (ap->link.device[sdev->id].class == ATA_DEV_ATAPI) {
697 /*
698 * NVIDIA reports that ADMA mode does not support ATAPI commands.
699 * Therefore ATAPI commands are sent through the legacy interface.
700 * However, the legacy interface only supports 32-bit DMA.
701 * Restrict DMA parameters as required by the legacy interface
702 * when an ATAPI device is connected.
703 */
704 segment_boundary = ATA_DMA_BOUNDARY;
705 /* Subtract 1 since an extra entry may be needed for padding, see
706 libata-scsi.c */
707 sg_tablesize = LIBATA_MAX_PRD - 1;
708
709 /* Since the legacy DMA engine is in use, we need to disable ADMA
710 on the port. */
711 adma_enable = 0;
712 nv_adma_register_mode(ap);
713 } else {
714 segment_boundary = NV_ADMA_DMA_BOUNDARY;
715 sg_tablesize = NV_ADMA_SGTBL_TOTAL_LEN;
716 adma_enable = 1;
717 }
718
719 pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &current_reg);
720
721 if (ap->port_no == 1)
722 config_mask = NV_MCP_SATA_CFG_20_PORT1_EN |
723 NV_MCP_SATA_CFG_20_PORT1_PWB_EN;
724 else
725 config_mask = NV_MCP_SATA_CFG_20_PORT0_EN |
726 NV_MCP_SATA_CFG_20_PORT0_PWB_EN;
727
728 if (adma_enable) {
729 new_reg = current_reg | config_mask;
730 pp->flags &= ~NV_ADMA_ATAPI_SETUP_COMPLETE;
731 } else {
732 new_reg = current_reg & ~config_mask;
733 pp->flags |= NV_ADMA_ATAPI_SETUP_COMPLETE;
734 }
735
736 if (current_reg != new_reg)
737 pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, new_reg);
738
739 port0 = ap->host->ports[0]->private_data;
740 port1 = ap->host->ports[1]->private_data;
741 sdev0 = ap->host->ports[0]->link.device[0].sdev;
742 sdev1 = ap->host->ports[1]->link.device[0].sdev;
743 if ((port0->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) ||
744 (port1->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)) {
745 /** We have to set the DMA mask to 32-bit if either port is in
746 ATAPI mode, since they are on the same PCI device which is
747 used for DMA mapping. If we set the mask we also need to set
748 the bounce limit on both ports to ensure that the block
749 layer doesn't feed addresses that cause DMA mapping to
750 choke. If either SCSI device is not allocated yet, it's OK
751 since that port will discover its correct setting when it
752 does get allocated.
753 Note: Setting 32-bit mask should not fail. */
754 if (sdev0)
755 blk_queue_bounce_limit(sdev0->request_queue,
756 ATA_DMA_MASK);
757 if (sdev1)
758 blk_queue_bounce_limit(sdev1->request_queue,
759 ATA_DMA_MASK);
760
761 pci_set_dma_mask(pdev, ATA_DMA_MASK);
762 } else {
763 /** This shouldn't fail as it was set to this value before */
764 pci_set_dma_mask(pdev, pp->adma_dma_mask);
765 if (sdev0)
766 blk_queue_bounce_limit(sdev0->request_queue,
767 pp->adma_dma_mask);
768 if (sdev1)
769 blk_queue_bounce_limit(sdev1->request_queue,
770 pp->adma_dma_mask);
771 }
772
773 blk_queue_segment_boundary(sdev->request_queue, segment_boundary);
774 blk_queue_max_hw_segments(sdev->request_queue, sg_tablesize);
775 ata_port_printk(ap, KERN_INFO,
776 "DMA mask 0x%llX, segment boundary 0x%lX, hw segs %hu\n",
777 (unsigned long long)*ap->host->dev->dma_mask,
778 segment_boundary, sg_tablesize);
779
780 spin_unlock_irqrestore(ap->lock, flags);
781
782 return rc;
783 }
784
785 static int nv_adma_check_atapi_dma(struct ata_queued_cmd *qc)
786 {
787 struct nv_adma_port_priv *pp = qc->ap->private_data;
788 return !(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE);
789 }
790
791 static void nv_adma_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
792 {
793 /* Other than when internal or pass-through commands are executed,
794 the only time this function will be called in ADMA mode will be
795 if a command fails. In the failure case we don't care about going
796 into register mode with ADMA commands pending, as the commands will
797 all shortly be aborted anyway. We assume that NCQ commands are not
798 issued via passthrough, which is the only way that switching into
799 ADMA mode could abort outstanding commands. */
800 nv_adma_register_mode(ap);
801
802 ata_sff_tf_read(ap, tf);
803 }
804
805 static unsigned int nv_adma_tf_to_cpb(struct ata_taskfile *tf, __le16 *cpb)
806 {
807 unsigned int idx = 0;
808
809 if (tf->flags & ATA_TFLAG_ISADDR) {
810 if (tf->flags & ATA_TFLAG_LBA48) {
811 cpb[idx++] = cpu_to_le16((ATA_REG_ERR << 8) | tf->hob_feature | WNB);
812 cpb[idx++] = cpu_to_le16((ATA_REG_NSECT << 8) | tf->hob_nsect);
813 cpb[idx++] = cpu_to_le16((ATA_REG_LBAL << 8) | tf->hob_lbal);
814 cpb[idx++] = cpu_to_le16((ATA_REG_LBAM << 8) | tf->hob_lbam);
815 cpb[idx++] = cpu_to_le16((ATA_REG_LBAH << 8) | tf->hob_lbah);
816 cpb[idx++] = cpu_to_le16((ATA_REG_ERR << 8) | tf->feature);
817 } else
818 cpb[idx++] = cpu_to_le16((ATA_REG_ERR << 8) | tf->feature | WNB);
819
820 cpb[idx++] = cpu_to_le16((ATA_REG_NSECT << 8) | tf->nsect);
821 cpb[idx++] = cpu_to_le16((ATA_REG_LBAL << 8) | tf->lbal);
822 cpb[idx++] = cpu_to_le16((ATA_REG_LBAM << 8) | tf->lbam);
823 cpb[idx++] = cpu_to_le16((ATA_REG_LBAH << 8) | tf->lbah);
824 }
825
826 if (tf->flags & ATA_TFLAG_DEVICE)
827 cpb[idx++] = cpu_to_le16((ATA_REG_DEVICE << 8) | tf->device);
828
829 cpb[idx++] = cpu_to_le16((ATA_REG_CMD << 8) | tf->command | CMDEND);
830
831 while (idx < 12)
832 cpb[idx++] = cpu_to_le16(IGN);
833
834 return idx;
835 }
836
837 static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
838 {
839 struct nv_adma_port_priv *pp = ap->private_data;
840 u8 flags = pp->cpb[cpb_num].resp_flags;
841
842 VPRINTK("CPB %d, flags=0x%x\n", cpb_num, flags);
843
844 if (unlikely((force_err ||
845 flags & (NV_CPB_RESP_ATA_ERR |
846 NV_CPB_RESP_CMD_ERR |
847 NV_CPB_RESP_CPB_ERR)))) {
848 struct ata_eh_info *ehi = &ap->link.eh_info;
849 int freeze = 0;
850
851 ata_ehi_clear_desc(ehi);
852 __ata_ehi_push_desc(ehi, "CPB resp_flags 0x%x: ", flags);
853 if (flags & NV_CPB_RESP_ATA_ERR) {
854 ata_ehi_push_desc(ehi, "ATA error");
855 ehi->err_mask |= AC_ERR_DEV;
856 } else if (flags & NV_CPB_RESP_CMD_ERR) {
857 ata_ehi_push_desc(ehi, "CMD error");
858 ehi->err_mask |= AC_ERR_DEV;
859 } else if (flags & NV_CPB_RESP_CPB_ERR) {
860 ata_ehi_push_desc(ehi, "CPB error");
861 ehi->err_mask |= AC_ERR_SYSTEM;
862 freeze = 1;
863 } else {
864 /* notifier error, but no error in CPB flags? */
865 ata_ehi_push_desc(ehi, "unknown");
866 ehi->err_mask |= AC_ERR_OTHER;
867 freeze = 1;
868 }
869 /* Kill all commands. EH will determine what actually failed. */
870 if (freeze)
871 ata_port_freeze(ap);
872 else
873 ata_port_abort(ap);
874 return 1;
875 }
876
877 if (likely(flags & NV_CPB_RESP_DONE)) {
878 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, cpb_num);
879 VPRINTK("CPB flags done, flags=0x%x\n", flags);
880 if (likely(qc)) {
881 DPRINTK("Completing qc from tag %d\n", cpb_num);
882 ata_qc_complete(qc);
883 } else {
884 struct ata_eh_info *ehi = &ap->link.eh_info;
885 /* Notifier bits set without a command may indicate the drive
886 is misbehaving. Raise host state machine violation on this
887 condition. */
888 ata_port_printk(ap, KERN_ERR,
889 "notifier for tag %d with no cmd?\n",
890 cpb_num);
891 ehi->err_mask |= AC_ERR_HSM;
892 ehi->action |= ATA_EH_RESET;
893 ata_port_freeze(ap);
894 return 1;
895 }
896 }
897 return 0;
898 }
899
900 static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
901 {
902 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
903
904 /* freeze if hotplugged */
905 if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
906 ata_port_freeze(ap);
907 return 1;
908 }
909
910 /* bail out if not our interrupt */
911 if (!(irq_stat & NV_INT_DEV))
912 return 0;
913
914 /* DEV interrupt w/ no active qc? */
915 if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) {
916 ata_sff_check_status(ap);
917 return 1;
918 }
919
920 /* handle interrupt */
921 return ata_sff_host_intr(ap, qc);
922 }
923
924 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
925 {
926 struct ata_host *host = dev_instance;
927 int i, handled = 0;
928 u32 notifier_clears[2];
929
930 spin_lock(&host->lock);
931
932 for (i = 0; i < host->n_ports; i++) {
933 struct ata_port *ap = host->ports[i];
934 notifier_clears[i] = 0;
935
936 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) {
937 struct nv_adma_port_priv *pp = ap->private_data;
938 void __iomem *mmio = pp->ctl_block;
939 u16 status;
940 u32 gen_ctl;
941 u32 notifier, notifier_error;
942
943 /* if ADMA is disabled, use standard ata interrupt handler */
944 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) {
945 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
946 >> (NV_INT_PORT_SHIFT * i);
947 handled += nv_host_intr(ap, irq_stat);
948 continue;
949 }
950
951 /* if in ATA register mode, check for standard interrupts */
952 if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
953 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
954 >> (NV_INT_PORT_SHIFT * i);
955 if (ata_tag_valid(ap->link.active_tag))
956 /** NV_INT_DEV indication seems unreliable at times
957 at least in ADMA mode. Force it on always when a
958 command is active, to prevent losing interrupts. */
959 irq_stat |= NV_INT_DEV;
960 handled += nv_host_intr(ap, irq_stat);
961 }
962
963 notifier = readl(mmio + NV_ADMA_NOTIFIER);
964 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
965 notifier_clears[i] = notifier | notifier_error;
966
967 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
968
969 if (!NV_ADMA_CHECK_INTR(gen_ctl, ap->port_no) && !notifier &&
970 !notifier_error)
971 /* Nothing to do */
972 continue;
973
974 status = readw(mmio + NV_ADMA_STAT);
975
976 /* Clear status. Ensure the controller sees the clearing before we start
977 looking at any of the CPB statuses, so that any CPB completions after
978 this point in the handler will raise another interrupt. */
979 writew(status, mmio + NV_ADMA_STAT);
980 readw(mmio + NV_ADMA_STAT); /* flush posted write */
981 rmb();
982
983 handled++; /* irq handled if we got here */
984
985 /* freeze if hotplugged or controller error */
986 if (unlikely(status & (NV_ADMA_STAT_HOTPLUG |
987 NV_ADMA_STAT_HOTUNPLUG |
988 NV_ADMA_STAT_TIMEOUT |
989 NV_ADMA_STAT_SERROR))) {
990 struct ata_eh_info *ehi = &ap->link.eh_info;
991
992 ata_ehi_clear_desc(ehi);
993 __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status);
994 if (status & NV_ADMA_STAT_TIMEOUT) {
995 ehi->err_mask |= AC_ERR_SYSTEM;
996 ata_ehi_push_desc(ehi, "timeout");
997 } else if (status & NV_ADMA_STAT_HOTPLUG) {
998 ata_ehi_hotplugged(ehi);
999 ata_ehi_push_desc(ehi, "hotplug");
1000 } else if (status & NV_ADMA_STAT_HOTUNPLUG) {
1001 ata_ehi_hotplugged(ehi);
1002 ata_ehi_push_desc(ehi, "hot unplug");
1003 } else if (status & NV_ADMA_STAT_SERROR) {
1004 /* let libata analyze SError and figure out the cause */
1005 ata_ehi_push_desc(ehi, "SError");
1006 } else
1007 ata_ehi_push_desc(ehi, "unknown");
1008 ata_port_freeze(ap);
1009 continue;
1010 }
1011
1012 if (status & (NV_ADMA_STAT_DONE |
1013 NV_ADMA_STAT_CPBERR |
1014 NV_ADMA_STAT_CMD_COMPLETE)) {
1015 u32 check_commands = notifier_clears[i];
1016 int pos, error = 0;
1017
1018 if (status & NV_ADMA_STAT_CPBERR) {
1019 /* Check all active commands */
1020 if (ata_tag_valid(ap->link.active_tag))
1021 check_commands = 1 <<
1022 ap->link.active_tag;
1023 else
1024 check_commands = ap->
1025 link.sactive;
1026 }
1027
1028 /** Check CPBs for completed commands */
1029 while ((pos = ffs(check_commands)) && !error) {
1030 pos--;
1031 error = nv_adma_check_cpb(ap, pos,
1032 notifier_error & (1 << pos));
1033 check_commands &= ~(1 << pos);
1034 }
1035 }
1036 }
1037 }
1038
1039 if (notifier_clears[0] || notifier_clears[1]) {
1040 /* Note: Both notifier clear registers must be written
1041 if either is set, even if one is zero, according to NVIDIA. */
1042 struct nv_adma_port_priv *pp = host->ports[0]->private_data;
1043 writel(notifier_clears[0], pp->notifier_clear_block);
1044 pp = host->ports[1]->private_data;
1045 writel(notifier_clears[1], pp->notifier_clear_block);
1046 }
1047
1048 spin_unlock(&host->lock);
1049
1050 return IRQ_RETVAL(handled);
1051 }
1052
1053 static void nv_adma_freeze(struct ata_port *ap)
1054 {
1055 struct nv_adma_port_priv *pp = ap->private_data;
1056 void __iomem *mmio = pp->ctl_block;
1057 u16 tmp;
1058
1059 nv_ck804_freeze(ap);
1060
1061 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
1062 return;
1063
1064 /* clear any outstanding CK804 notifications */
1065 writeb(NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
1066 ap->host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
1067
1068 /* Disable interrupt */
1069 tmp = readw(mmio + NV_ADMA_CTL);
1070 writew(tmp & ~(NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
1071 mmio + NV_ADMA_CTL);
1072 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1073 }
1074
1075 static void nv_adma_thaw(struct ata_port *ap)
1076 {
1077 struct nv_adma_port_priv *pp = ap->private_data;
1078 void __iomem *mmio = pp->ctl_block;
1079 u16 tmp;
1080
1081 nv_ck804_thaw(ap);
1082
1083 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
1084 return;
1085
1086 /* Enable interrupt */
1087 tmp = readw(mmio + NV_ADMA_CTL);
1088 writew(tmp | (NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
1089 mmio + NV_ADMA_CTL);
1090 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1091 }
1092
1093 static void nv_adma_irq_clear(struct ata_port *ap)
1094 {
1095 struct nv_adma_port_priv *pp = ap->private_data;
1096 void __iomem *mmio = pp->ctl_block;
1097 u32 notifier_clears[2];
1098
1099 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) {
1100 ata_sff_irq_clear(ap);
1101 return;
1102 }
1103
1104 /* clear any outstanding CK804 notifications */
1105 writeb(NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
1106 ap->host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
1107
1108 /* clear ADMA status */
1109 writew(0xffff, mmio + NV_ADMA_STAT);
1110
1111 /* clear notifiers - note both ports need to be written with
1112 something even though we are only clearing on one */
1113 if (ap->port_no == 0) {
1114 notifier_clears[0] = 0xFFFFFFFF;
1115 notifier_clears[1] = 0;
1116 } else {
1117 notifier_clears[0] = 0;
1118 notifier_clears[1] = 0xFFFFFFFF;
1119 }
1120 pp = ap->host->ports[0]->private_data;
1121 writel(notifier_clears[0], pp->notifier_clear_block);
1122 pp = ap->host->ports[1]->private_data;
1123 writel(notifier_clears[1], pp->notifier_clear_block);
1124 }
1125
1126 static void nv_adma_post_internal_cmd(struct ata_queued_cmd *qc)
1127 {
1128 struct nv_adma_port_priv *pp = qc->ap->private_data;
1129
1130 if (pp->flags & NV_ADMA_PORT_REGISTER_MODE)
1131 ata_sff_post_internal_cmd(qc);
1132 }
1133
1134 static int nv_adma_port_start(struct ata_port *ap)
1135 {
1136 struct device *dev = ap->host->dev;
1137 struct nv_adma_port_priv *pp;
1138 int rc;
1139 void *mem;
1140 dma_addr_t mem_dma;
1141 void __iomem *mmio;
1142 struct pci_dev *pdev = to_pci_dev(dev);
1143 u16 tmp;
1144
1145 VPRINTK("ENTER\n");
1146
1147 /* Ensure DMA mask is set to 32-bit before allocating legacy PRD and
1148 pad buffers */
1149 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1150 if (rc)
1151 return rc;
1152 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
1153 if (rc)
1154 return rc;
1155
1156 rc = ata_port_start(ap);
1157 if (rc)
1158 return rc;
1159
1160 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
1161 if (!pp)
1162 return -ENOMEM;
1163
1164 mmio = ap->host->iomap[NV_MMIO_BAR] + NV_ADMA_PORT +
1165 ap->port_no * NV_ADMA_PORT_SIZE;
1166 pp->ctl_block = mmio;
1167 pp->gen_block = ap->host->iomap[NV_MMIO_BAR] + NV_ADMA_GEN;
1168 pp->notifier_clear_block = pp->gen_block +
1169 NV_ADMA_NOTIFIER_CLEAR + (4 * ap->port_no);
1170
1171 /* Now that the legacy PRD and padding buffer are allocated we can
1172 safely raise the DMA mask to allocate the CPB/APRD table.
1173 These are allowed to fail since we store the value that ends up
1174 being used to set as the bounce limit in slave_config later if
1175 needed. */
1176 pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
1177 pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
1178 pp->adma_dma_mask = *dev->dma_mask;
1179
1180 mem = dmam_alloc_coherent(dev, NV_ADMA_PORT_PRIV_DMA_SZ,
1181 &mem_dma, GFP_KERNEL);
1182 if (!mem)
1183 return -ENOMEM;
1184 memset(mem, 0, NV_ADMA_PORT_PRIV_DMA_SZ);
1185
1186 /*
1187 * First item in chunk of DMA memory:
1188 * 128-byte command parameter block (CPB)
1189 * one for each command tag
1190 */
1191 pp->cpb = mem;
1192 pp->cpb_dma = mem_dma;
1193
1194 writel(mem_dma & 0xFFFFFFFF, mmio + NV_ADMA_CPB_BASE_LOW);
1195 writel((mem_dma >> 16) >> 16, mmio + NV_ADMA_CPB_BASE_HIGH);
1196
1197 mem += NV_ADMA_MAX_CPBS * NV_ADMA_CPB_SZ;
1198 mem_dma += NV_ADMA_MAX_CPBS * NV_ADMA_CPB_SZ;
1199
1200 /*
1201 * Second item: block of ADMA_SGTBL_LEN s/g entries
1202 */
1203 pp->aprd = mem;
1204 pp->aprd_dma = mem_dma;
1205
1206 ap->private_data = pp;
1207
1208 /* clear any outstanding interrupt conditions */
1209 writew(0xffff, mmio + NV_ADMA_STAT);
1210
1211 /* initialize port variables */
1212 pp->flags = NV_ADMA_PORT_REGISTER_MODE;
1213
1214 /* clear CPB fetch count */
1215 writew(0, mmio + NV_ADMA_CPB_COUNT);
1216
1217 /* clear GO for register mode, enable interrupt */
1218 tmp = readw(mmio + NV_ADMA_CTL);
1219 writew((tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
1220 NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
1221
1222 tmp = readw(mmio + NV_ADMA_CTL);
1223 writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1224 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1225 udelay(1);
1226 writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1227 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1228
1229 return 0;
1230 }
1231
1232 static void nv_adma_port_stop(struct ata_port *ap)
1233 {
1234 struct nv_adma_port_priv *pp = ap->private_data;
1235 void __iomem *mmio = pp->ctl_block;
1236
1237 VPRINTK("ENTER\n");
1238 writew(0, mmio + NV_ADMA_CTL);
1239 }
1240
1241 #ifdef CONFIG_PM
1242 static int nv_adma_port_suspend(struct ata_port *ap, pm_message_t mesg)
1243 {
1244 struct nv_adma_port_priv *pp = ap->private_data;
1245 void __iomem *mmio = pp->ctl_block;
1246
1247 /* Go to register mode - clears GO */
1248 nv_adma_register_mode(ap);
1249
1250 /* clear CPB fetch count */
1251 writew(0, mmio + NV_ADMA_CPB_COUNT);
1252
1253 /* disable interrupt, shut down port */
1254 writew(0, mmio + NV_ADMA_CTL);
1255
1256 return 0;
1257 }
1258
1259 static int nv_adma_port_resume(struct ata_port *ap)
1260 {
1261 struct nv_adma_port_priv *pp = ap->private_data;
1262 void __iomem *mmio = pp->ctl_block;
1263 u16 tmp;
1264
1265 /* set CPB block location */
1266 writel(pp->cpb_dma & 0xFFFFFFFF, mmio + NV_ADMA_CPB_BASE_LOW);
1267 writel((pp->cpb_dma >> 16) >> 16, mmio + NV_ADMA_CPB_BASE_HIGH);
1268
1269 /* clear any outstanding interrupt conditions */
1270 writew(0xffff, mmio + NV_ADMA_STAT);
1271
1272 /* initialize port variables */
1273 pp->flags |= NV_ADMA_PORT_REGISTER_MODE;
1274
1275 /* clear CPB fetch count */
1276 writew(0, mmio + NV_ADMA_CPB_COUNT);
1277
1278 /* clear GO for register mode, enable interrupt */
1279 tmp = readw(mmio + NV_ADMA_CTL);
1280 writew((tmp & ~NV_ADMA_CTL_GO) | NV_ADMA_CTL_AIEN |
1281 NV_ADMA_CTL_HOTPLUG_IEN, mmio + NV_ADMA_CTL);
1282
1283 tmp = readw(mmio + NV_ADMA_CTL);
1284 writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1285 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1286 udelay(1);
1287 writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1288 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1289
1290 return 0;
1291 }
1292 #endif
1293
1294 static void nv_adma_setup_port(struct ata_port *ap)
1295 {
1296 void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1297 struct ata_ioports *ioport = &ap->ioaddr;
1298
1299 VPRINTK("ENTER\n");
1300
1301 mmio += NV_ADMA_PORT + ap->port_no * NV_ADMA_PORT_SIZE;
1302
1303 ioport->cmd_addr = mmio;
1304 ioport->data_addr = mmio + (ATA_REG_DATA * 4);
1305 ioport->error_addr =
1306 ioport->feature_addr = mmio + (ATA_REG_ERR * 4);
1307 ioport->nsect_addr = mmio + (ATA_REG_NSECT * 4);
1308 ioport->lbal_addr = mmio + (ATA_REG_LBAL * 4);
1309 ioport->lbam_addr = mmio + (ATA_REG_LBAM * 4);
1310 ioport->lbah_addr = mmio + (ATA_REG_LBAH * 4);
1311 ioport->device_addr = mmio + (ATA_REG_DEVICE * 4);
1312 ioport->status_addr =
1313 ioport->command_addr = mmio + (ATA_REG_STATUS * 4);
1314 ioport->altstatus_addr =
1315 ioport->ctl_addr = mmio + 0x20;
1316 }
1317
1318 static int nv_adma_host_init(struct ata_host *host)
1319 {
1320 struct pci_dev *pdev = to_pci_dev(host->dev);
1321 unsigned int i;
1322 u32 tmp32;
1323
1324 VPRINTK("ENTER\n");
1325
1326 /* enable ADMA on the ports */
1327 pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
1328 tmp32 |= NV_MCP_SATA_CFG_20_PORT0_EN |
1329 NV_MCP_SATA_CFG_20_PORT0_PWB_EN |
1330 NV_MCP_SATA_CFG_20_PORT1_EN |
1331 NV_MCP_SATA_CFG_20_PORT1_PWB_EN;
1332
1333 pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
1334
1335 for (i = 0; i < host->n_ports; i++)
1336 nv_adma_setup_port(host->ports[i]);
1337
1338 return 0;
1339 }
1340
1341 static void nv_adma_fill_aprd(struct ata_queued_cmd *qc,
1342 struct scatterlist *sg,
1343 int idx,
1344 struct nv_adma_prd *aprd)
1345 {
1346 u8 flags = 0;
1347 if (qc->tf.flags & ATA_TFLAG_WRITE)
1348 flags |= NV_APRD_WRITE;
1349 if (idx == qc->n_elem - 1)
1350 flags |= NV_APRD_END;
1351 else if (idx != 4)
1352 flags |= NV_APRD_CONT;
1353
1354 aprd->addr = cpu_to_le64(((u64)sg_dma_address(sg)));
1355 aprd->len = cpu_to_le32(((u32)sg_dma_len(sg))); /* len in bytes */
1356 aprd->flags = flags;
1357 aprd->packet_len = 0;
1358 }
1359
1360 static void nv_adma_fill_sg(struct ata_queued_cmd *qc, struct nv_adma_cpb *cpb)
1361 {
1362 struct nv_adma_port_priv *pp = qc->ap->private_data;
1363 struct nv_adma_prd *aprd;
1364 struct scatterlist *sg;
1365 unsigned int si;
1366
1367 VPRINTK("ENTER\n");
1368
1369 for_each_sg(qc->sg, sg, qc->n_elem, si) {
1370 aprd = (si < 5) ? &cpb->aprd[si] :
1371 &pp->aprd[NV_ADMA_SGTBL_LEN * qc->tag + (si-5)];
1372 nv_adma_fill_aprd(qc, sg, si, aprd);
1373 }
1374 if (si > 5)
1375 cpb->next_aprd = cpu_to_le64(((u64)(pp->aprd_dma + NV_ADMA_SGTBL_SZ * qc->tag)));
1376 else
1377 cpb->next_aprd = cpu_to_le64(0);
1378 }
1379
1380 static int nv_adma_use_reg_mode(struct ata_queued_cmd *qc)
1381 {
1382 struct nv_adma_port_priv *pp = qc->ap->private_data;
1383
1384 /* ADMA engine can only be used for non-ATAPI DMA commands,
1385 or interrupt-driven no-data commands. */
1386 if ((pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) ||
1387 (qc->tf.flags & ATA_TFLAG_POLLING))
1388 return 1;
1389
1390 if ((qc->flags & ATA_QCFLAG_DMAMAP) ||
1391 (qc->tf.protocol == ATA_PROT_NODATA))
1392 return 0;
1393
1394 return 1;
1395 }
1396
1397 static void nv_adma_qc_prep(struct ata_queued_cmd *qc)
1398 {
1399 struct nv_adma_port_priv *pp = qc->ap->private_data;
1400 struct nv_adma_cpb *cpb = &pp->cpb[qc->tag];
1401 u8 ctl_flags = NV_CPB_CTL_CPB_VALID |
1402 NV_CPB_CTL_IEN;
1403
1404 if (nv_adma_use_reg_mode(qc)) {
1405 BUG_ON(!(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) &&
1406 (qc->flags & ATA_QCFLAG_DMAMAP));
1407 nv_adma_register_mode(qc->ap);
1408 ata_sff_qc_prep(qc);
1409 return;
1410 }
1411
1412 cpb->resp_flags = NV_CPB_RESP_DONE;
1413 wmb();
1414 cpb->ctl_flags = 0;
1415 wmb();
1416
1417 cpb->len = 3;
1418 cpb->tag = qc->tag;
1419 cpb->next_cpb_idx = 0;
1420
1421 /* turn on NCQ flags for NCQ commands */
1422 if (qc->tf.protocol == ATA_PROT_NCQ)
1423 ctl_flags |= NV_CPB_CTL_QUEUE | NV_CPB_CTL_FPDMA;
1424
1425 VPRINTK("qc->flags = 0x%lx\n", qc->flags);
1426
1427 nv_adma_tf_to_cpb(&qc->tf, cpb->tf);
1428
1429 if (qc->flags & ATA_QCFLAG_DMAMAP) {
1430 nv_adma_fill_sg(qc, cpb);
1431 ctl_flags |= NV_CPB_CTL_APRD_VALID;
1432 } else
1433 memset(&cpb->aprd[0], 0, sizeof(struct nv_adma_prd) * 5);
1434
1435 /* Be paranoid and don't let the device see NV_CPB_CTL_CPB_VALID
1436 until we are finished filling in all of the contents */
1437 wmb();
1438 cpb->ctl_flags = ctl_flags;
1439 wmb();
1440 cpb->resp_flags = 0;
1441 }
1442
1443 static unsigned int nv_adma_qc_issue(struct ata_queued_cmd *qc)
1444 {
1445 struct nv_adma_port_priv *pp = qc->ap->private_data;
1446 void __iomem *mmio = pp->ctl_block;
1447 int curr_ncq = (qc->tf.protocol == ATA_PROT_NCQ);
1448
1449 VPRINTK("ENTER\n");
1450
1451 /* We can't handle result taskfile with NCQ commands, since
1452 retrieving the taskfile switches us out of ADMA mode and would abort
1453 existing commands. */
1454 if (unlikely(qc->tf.protocol == ATA_PROT_NCQ &&
1455 (qc->flags & ATA_QCFLAG_RESULT_TF))) {
1456 ata_dev_printk(qc->dev, KERN_ERR,
1457 "NCQ w/ RESULT_TF not allowed\n");
1458 return AC_ERR_SYSTEM;
1459 }
1460
1461 if (nv_adma_use_reg_mode(qc)) {
1462 /* use ATA register mode */
1463 VPRINTK("using ATA register mode: 0x%lx\n", qc->flags);
1464 BUG_ON(!(pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) &&
1465 (qc->flags & ATA_QCFLAG_DMAMAP));
1466 nv_adma_register_mode(qc->ap);
1467 return ata_sff_qc_issue(qc);
1468 } else
1469 nv_adma_mode(qc->ap);
1470
1471 /* write append register, command tag in lower 8 bits
1472 and (number of cpbs to append -1) in top 8 bits */
1473 wmb();
1474
1475 if (curr_ncq != pp->last_issue_ncq) {
1476 /* Seems to need some delay before switching between NCQ and
1477 non-NCQ commands, else we get command timeouts and such. */
1478 udelay(20);
1479 pp->last_issue_ncq = curr_ncq;
1480 }
1481
1482 writew(qc->tag, mmio + NV_ADMA_APPEND);
1483
1484 DPRINTK("Issued tag %u\n", qc->tag);
1485
1486 return 0;
1487 }
1488
1489 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
1490 {
1491 struct ata_host *host = dev_instance;
1492 unsigned int i;
1493 unsigned int handled = 0;
1494 unsigned long flags;
1495
1496 spin_lock_irqsave(&host->lock, flags);
1497
1498 for (i = 0; i < host->n_ports; i++) {
1499 struct ata_port *ap;
1500
1501 ap = host->ports[i];
1502 if (ap &&
1503 !(ap->flags & ATA_FLAG_DISABLED)) {
1504 struct ata_queued_cmd *qc;
1505
1506 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1507 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
1508 handled += ata_sff_host_intr(ap, qc);
1509 else
1510 // No request pending? Clear interrupt status
1511 // anyway, in case there's one pending.
1512 ap->ops->sff_check_status(ap);
1513 }
1514
1515 }
1516
1517 spin_unlock_irqrestore(&host->lock, flags);
1518
1519 return IRQ_RETVAL(handled);
1520 }
1521
1522 static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
1523 {
1524 int i, handled = 0;
1525
1526 for (i = 0; i < host->n_ports; i++) {
1527 struct ata_port *ap = host->ports[i];
1528
1529 if (ap && !(ap->flags & ATA_FLAG_DISABLED))
1530 handled += nv_host_intr(ap, irq_stat);
1531
1532 irq_stat >>= NV_INT_PORT_SHIFT;
1533 }
1534
1535 return IRQ_RETVAL(handled);
1536 }
1537
1538 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance)
1539 {
1540 struct ata_host *host = dev_instance;
1541 u8 irq_stat;
1542 irqreturn_t ret;
1543
1544 spin_lock(&host->lock);
1545 irq_stat = ioread8(host->ports[0]->ioaddr.scr_addr + NV_INT_STATUS);
1546 ret = nv_do_interrupt(host, irq_stat);
1547 spin_unlock(&host->lock);
1548
1549 return ret;
1550 }
1551
1552 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance)
1553 {
1554 struct ata_host *host = dev_instance;
1555 u8 irq_stat;
1556 irqreturn_t ret;
1557
1558 spin_lock(&host->lock);
1559 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
1560 ret = nv_do_interrupt(host, irq_stat);
1561 spin_unlock(&host->lock);
1562
1563 return ret;
1564 }
1565
1566 static int nv_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
1567 {
1568 if (sc_reg > SCR_CONTROL)
1569 return -EINVAL;
1570
1571 *val = ioread32(link->ap->ioaddr.scr_addr + (sc_reg * 4));
1572 return 0;
1573 }
1574
1575 static int nv_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
1576 {
1577 if (sc_reg > SCR_CONTROL)
1578 return -EINVAL;
1579
1580 iowrite32(val, link->ap->ioaddr.scr_addr + (sc_reg * 4));
1581 return 0;
1582 }
1583
1584 static int nv_hardreset(struct ata_link *link, unsigned int *class,
1585 unsigned long deadline)
1586 {
1587 struct ata_eh_context *ehc = &link->eh_context;
1588
1589 /* Do hardreset iff it's post-boot probing, please read the
1590 * comment above port ops for details.
1591 */
1592 if (!(link->ap->pflags & ATA_PFLAG_LOADING) &&
1593 !ata_dev_enabled(link->device))
1594 sata_link_hardreset(link, sata_deb_timing_hotplug, deadline,
1595 NULL, NULL);
1596 else if (!(ehc->i.flags & ATA_EHI_QUIET))
1597 ata_link_printk(link, KERN_INFO,
1598 "nv: skipping hardreset on occupied port\n");
1599
1600 /* device signature acquisition is unreliable */
1601 return -EAGAIN;
1602 }
1603
1604 static void nv_nf2_freeze(struct ata_port *ap)
1605 {
1606 void __iomem *scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
1607 int shift = ap->port_no * NV_INT_PORT_SHIFT;
1608 u8 mask;
1609
1610 mask = ioread8(scr_addr + NV_INT_ENABLE);
1611 mask &= ~(NV_INT_ALL << shift);
1612 iowrite8(mask, scr_addr + NV_INT_ENABLE);
1613 }
1614
1615 static void nv_nf2_thaw(struct ata_port *ap)
1616 {
1617 void __iomem *scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
1618 int shift = ap->port_no * NV_INT_PORT_SHIFT;
1619 u8 mask;
1620
1621 iowrite8(NV_INT_ALL << shift, scr_addr + NV_INT_STATUS);
1622
1623 mask = ioread8(scr_addr + NV_INT_ENABLE);
1624 mask |= (NV_INT_MASK << shift);
1625 iowrite8(mask, scr_addr + NV_INT_ENABLE);
1626 }
1627
1628 static void nv_ck804_freeze(struct ata_port *ap)
1629 {
1630 void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1631 int shift = ap->port_no * NV_INT_PORT_SHIFT;
1632 u8 mask;
1633
1634 mask = readb(mmio_base + NV_INT_ENABLE_CK804);
1635 mask &= ~(NV_INT_ALL << shift);
1636 writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
1637 }
1638
1639 static void nv_ck804_thaw(struct ata_port *ap)
1640 {
1641 void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1642 int shift = ap->port_no * NV_INT_PORT_SHIFT;
1643 u8 mask;
1644
1645 writeb(NV_INT_ALL << shift, mmio_base + NV_INT_STATUS_CK804);
1646
1647 mask = readb(mmio_base + NV_INT_ENABLE_CK804);
1648 mask |= (NV_INT_MASK << shift);
1649 writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
1650 }
1651
1652 static void nv_mcp55_freeze(struct ata_port *ap)
1653 {
1654 void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1655 int shift = ap->port_no * NV_INT_PORT_SHIFT_MCP55;
1656 u32 mask;
1657
1658 writel(NV_INT_ALL_MCP55 << shift, mmio_base + NV_INT_STATUS_MCP55);
1659
1660 mask = readl(mmio_base + NV_INT_ENABLE_MCP55);
1661 mask &= ~(NV_INT_ALL_MCP55 << shift);
1662 writel(mask, mmio_base + NV_INT_ENABLE_MCP55);
1663 ata_sff_freeze(ap);
1664 }
1665
1666 static void nv_mcp55_thaw(struct ata_port *ap)
1667 {
1668 void __iomem *mmio_base = ap->host->iomap[NV_MMIO_BAR];
1669 int shift = ap->port_no * NV_INT_PORT_SHIFT_MCP55;
1670 u32 mask;
1671
1672 writel(NV_INT_ALL_MCP55 << shift, mmio_base + NV_INT_STATUS_MCP55);
1673
1674 mask = readl(mmio_base + NV_INT_ENABLE_MCP55);
1675 mask |= (NV_INT_MASK_MCP55 << shift);
1676 writel(mask, mmio_base + NV_INT_ENABLE_MCP55);
1677 ata_sff_thaw(ap);
1678 }
1679
1680 static void nv_adma_error_handler(struct ata_port *ap)
1681 {
1682 struct nv_adma_port_priv *pp = ap->private_data;
1683 if (!(pp->flags & NV_ADMA_PORT_REGISTER_MODE)) {
1684 void __iomem *mmio = pp->ctl_block;
1685 int i;
1686 u16 tmp;
1687
1688 if (ata_tag_valid(ap->link.active_tag) || ap->link.sactive) {
1689 u32 notifier = readl(mmio + NV_ADMA_NOTIFIER);
1690 u32 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
1691 u32 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
1692 u32 status = readw(mmio + NV_ADMA_STAT);
1693 u8 cpb_count = readb(mmio + NV_ADMA_CPB_COUNT);
1694 u8 next_cpb_idx = readb(mmio + NV_ADMA_NEXT_CPB_IDX);
1695
1696 ata_port_printk(ap, KERN_ERR,
1697 "EH in ADMA mode, notifier 0x%X "
1698 "notifier_error 0x%X gen_ctl 0x%X status 0x%X "
1699 "next cpb count 0x%X next cpb idx 0x%x\n",
1700 notifier, notifier_error, gen_ctl, status,
1701 cpb_count, next_cpb_idx);
1702
1703 for (i = 0; i < NV_ADMA_MAX_CPBS; i++) {
1704 struct nv_adma_cpb *cpb = &pp->cpb[i];
1705 if ((ata_tag_valid(ap->link.active_tag) && i == ap->link.active_tag) ||
1706 ap->link.sactive & (1 << i))
1707 ata_port_printk(ap, KERN_ERR,
1708 "CPB %d: ctl_flags 0x%x, resp_flags 0x%x\n",
1709 i, cpb->ctl_flags, cpb->resp_flags);
1710 }
1711 }
1712
1713 /* Push us back into port register mode for error handling. */
1714 nv_adma_register_mode(ap);
1715
1716 /* Mark all of the CPBs as invalid to prevent them from
1717 being executed */
1718 for (i = 0; i < NV_ADMA_MAX_CPBS; i++)
1719 pp->cpb[i].ctl_flags &= ~NV_CPB_CTL_CPB_VALID;
1720
1721 /* clear CPB fetch count */
1722 writew(0, mmio + NV_ADMA_CPB_COUNT);
1723
1724 /* Reset channel */
1725 tmp = readw(mmio + NV_ADMA_CTL);
1726 writew(tmp | NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1727 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1728 udelay(1);
1729 writew(tmp & ~NV_ADMA_CTL_CHANNEL_RESET, mmio + NV_ADMA_CTL);
1730 readw(mmio + NV_ADMA_CTL); /* flush posted write */
1731 }
1732
1733 ata_sff_error_handler(ap);
1734 }
1735
1736 static void nv_swncq_qc_to_dq(struct ata_port *ap, struct ata_queued_cmd *qc)
1737 {
1738 struct nv_swncq_port_priv *pp = ap->private_data;
1739 struct defer_queue *dq = &pp->defer_queue;
1740
1741 /* queue is full */
1742 WARN_ON(dq->tail - dq->head == ATA_MAX_QUEUE);
1743 dq->defer_bits |= (1 << qc->tag);
1744 dq->tag[dq->tail++ & (ATA_MAX_QUEUE - 1)] = qc->tag;
1745 }
1746
1747 static struct ata_queued_cmd *nv_swncq_qc_from_dq(struct ata_port *ap)
1748 {
1749 struct nv_swncq_port_priv *pp = ap->private_data;
1750 struct defer_queue *dq = &pp->defer_queue;
1751 unsigned int tag;
1752
1753 if (dq->head == dq->tail) /* null queue */
1754 return NULL;
1755
1756 tag = dq->tag[dq->head & (ATA_MAX_QUEUE - 1)];
1757 dq->tag[dq->head++ & (ATA_MAX_QUEUE - 1)] = ATA_TAG_POISON;
1758 WARN_ON(!(dq->defer_bits & (1 << tag)));
1759 dq->defer_bits &= ~(1 << tag);
1760
1761 return ata_qc_from_tag(ap, tag);
1762 }
1763
1764 static void nv_swncq_fis_reinit(struct ata_port *ap)
1765 {
1766 struct nv_swncq_port_priv *pp = ap->private_data;
1767
1768 pp->dhfis_bits = 0;
1769 pp->dmafis_bits = 0;
1770 pp->sdbfis_bits = 0;
1771 pp->ncq_flags = 0;
1772 }
1773
1774 static void nv_swncq_pp_reinit(struct ata_port *ap)
1775 {
1776 struct nv_swncq_port_priv *pp = ap->private_data;
1777 struct defer_queue *dq = &pp->defer_queue;
1778
1779 dq->head = 0;
1780 dq->tail = 0;
1781 dq->defer_bits = 0;
1782 pp->qc_active = 0;
1783 pp->last_issue_tag = ATA_TAG_POISON;
1784 nv_swncq_fis_reinit(ap);
1785 }
1786
1787 static void nv_swncq_irq_clear(struct ata_port *ap, u16 fis)
1788 {
1789 struct nv_swncq_port_priv *pp = ap->private_data;
1790
1791 writew(fis, pp->irq_block);
1792 }
1793
1794 static void __ata_bmdma_stop(struct ata_port *ap)
1795 {
1796 struct ata_queued_cmd qc;
1797
1798 qc.ap = ap;
1799 ata_bmdma_stop(&qc);
1800 }
1801
1802 static void nv_swncq_ncq_stop(struct ata_port *ap)
1803 {
1804 struct nv_swncq_port_priv *pp = ap->private_data;
1805 unsigned int i;
1806 u32 sactive;
1807 u32 done_mask;
1808
1809 ata_port_printk(ap, KERN_ERR,
1810 "EH in SWNCQ mode,QC:qc_active 0x%X sactive 0x%X\n",
1811 ap->qc_active, ap->link.sactive);
1812 ata_port_printk(ap, KERN_ERR,
1813 "SWNCQ:qc_active 0x%X defer_bits 0x%X last_issue_tag 0x%x\n "
1814 "dhfis 0x%X dmafis 0x%X sdbfis 0x%X\n",
1815 pp->qc_active, pp->defer_queue.defer_bits, pp->last_issue_tag,
1816 pp->dhfis_bits, pp->dmafis_bits, pp->sdbfis_bits);
1817
1818 ata_port_printk(ap, KERN_ERR, "ATA_REG 0x%X ERR_REG 0x%X\n",
1819 ap->ops->sff_check_status(ap),
1820 ioread8(ap->ioaddr.error_addr));
1821
1822 sactive = readl(pp->sactive_block);
1823 done_mask = pp->qc_active ^ sactive;
1824
1825 ata_port_printk(ap, KERN_ERR, "tag : dhfis dmafis sdbfis sacitve\n");
1826 for (i = 0; i < ATA_MAX_QUEUE; i++) {
1827 u8 err = 0;
1828 if (pp->qc_active & (1 << i))
1829 err = 0;
1830 else if (done_mask & (1 << i))
1831 err = 1;
1832 else
1833 continue;
1834
1835 ata_port_printk(ap, KERN_ERR,
1836 "tag 0x%x: %01x %01x %01x %01x %s\n", i,
1837 (pp->dhfis_bits >> i) & 0x1,
1838 (pp->dmafis_bits >> i) & 0x1,
1839 (pp->sdbfis_bits >> i) & 0x1,
1840 (sactive >> i) & 0x1,
1841 (err ? "error! tag doesn't exit" : " "));
1842 }
1843
1844 nv_swncq_pp_reinit(ap);
1845 ap->ops->sff_irq_clear(ap);
1846 __ata_bmdma_stop(ap);
1847 nv_swncq_irq_clear(ap, 0xffff);
1848 }
1849
1850 static void nv_swncq_error_handler(struct ata_port *ap)
1851 {
1852 struct ata_eh_context *ehc = &ap->link.eh_context;
1853
1854 if (ap->link.sactive) {
1855 nv_swncq_ncq_stop(ap);
1856 ehc->i.action |= ATA_EH_RESET;
1857 }
1858
1859 ata_sff_error_handler(ap);
1860 }
1861
1862 #ifdef CONFIG_PM
1863 static int nv_swncq_port_suspend(struct ata_port *ap, pm_message_t mesg)
1864 {
1865 void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1866 u32 tmp;
1867
1868 /* clear irq */
1869 writel(~0, mmio + NV_INT_STATUS_MCP55);
1870
1871 /* disable irq */
1872 writel(0, mmio + NV_INT_ENABLE_MCP55);
1873
1874 /* disable swncq */
1875 tmp = readl(mmio + NV_CTL_MCP55);
1876 tmp &= ~(NV_CTL_PRI_SWNCQ | NV_CTL_SEC_SWNCQ);
1877 writel(tmp, mmio + NV_CTL_MCP55);
1878
1879 return 0;
1880 }
1881
1882 static int nv_swncq_port_resume(struct ata_port *ap)
1883 {
1884 void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1885 u32 tmp;
1886
1887 /* clear irq */
1888 writel(~0, mmio + NV_INT_STATUS_MCP55);
1889
1890 /* enable irq */
1891 writel(0x00fd00fd, mmio + NV_INT_ENABLE_MCP55);
1892
1893 /* enable swncq */
1894 tmp = readl(mmio + NV_CTL_MCP55);
1895 writel(tmp | NV_CTL_PRI_SWNCQ | NV_CTL_SEC_SWNCQ, mmio + NV_CTL_MCP55);
1896
1897 return 0;
1898 }
1899 #endif
1900
1901 static void nv_swncq_host_init(struct ata_host *host)
1902 {
1903 u32 tmp;
1904 void __iomem *mmio = host->iomap[NV_MMIO_BAR];
1905 struct pci_dev *pdev = to_pci_dev(host->dev);
1906 u8 regval;
1907
1908 /* disable ECO 398 */
1909 pci_read_config_byte(pdev, 0x7f, &regval);
1910 regval &= ~(1 << 7);
1911 pci_write_config_byte(pdev, 0x7f, regval);
1912
1913 /* enable swncq */
1914 tmp = readl(mmio + NV_CTL_MCP55);
1915 VPRINTK("HOST_CTL:0x%X\n", tmp);
1916 writel(tmp | NV_CTL_PRI_SWNCQ | NV_CTL_SEC_SWNCQ, mmio + NV_CTL_MCP55);
1917
1918 /* enable irq intr */
1919 tmp = readl(mmio + NV_INT_ENABLE_MCP55);
1920 VPRINTK("HOST_ENABLE:0x%X\n", tmp);
1921 writel(tmp | 0x00fd00fd, mmio + NV_INT_ENABLE_MCP55);
1922
1923 /* clear port irq */
1924 writel(~0x0, mmio + NV_INT_STATUS_MCP55);
1925 }
1926
1927 static int nv_swncq_slave_config(struct scsi_device *sdev)
1928 {
1929 struct ata_port *ap = ata_shost_to_port(sdev->host);
1930 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
1931 struct ata_device *dev;
1932 int rc;
1933 u8 rev;
1934 u8 check_maxtor = 0;
1935 unsigned char model_num[ATA_ID_PROD_LEN + 1];
1936
1937 rc = ata_scsi_slave_config(sdev);
1938 if (sdev->id >= ATA_MAX_DEVICES || sdev->channel || sdev->lun)
1939 /* Not a proper libata device, ignore */
1940 return rc;
1941
1942 dev = &ap->link.device[sdev->id];
1943 if (!(ap->flags & ATA_FLAG_NCQ) || dev->class == ATA_DEV_ATAPI)
1944 return rc;
1945
1946 /* if MCP51 and Maxtor, then disable ncq */
1947 if (pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA ||
1948 pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2)
1949 check_maxtor = 1;
1950
1951 /* if MCP55 and rev <= a2 and Maxtor, then disable ncq */
1952 if (pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA ||
1953 pdev->device == PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2) {
1954 pci_read_config_byte(pdev, 0x8, &rev);
1955 if (rev <= 0xa2)
1956 check_maxtor = 1;
1957 }
1958
1959 if (!check_maxtor)
1960 return rc;
1961
1962 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
1963
1964 if (strncmp(model_num, "Maxtor", 6) == 0) {
1965 ata_scsi_change_queue_depth(sdev, 1);
1966 ata_dev_printk(dev, KERN_NOTICE,
1967 "Disabling SWNCQ mode (depth %x)\n", sdev->queue_depth);
1968 }
1969
1970 return rc;
1971 }
1972
1973 static int nv_swncq_port_start(struct ata_port *ap)
1974 {
1975 struct device *dev = ap->host->dev;
1976 void __iomem *mmio = ap->host->iomap[NV_MMIO_BAR];
1977 struct nv_swncq_port_priv *pp;
1978 int rc;
1979
1980 rc = ata_port_start(ap);
1981 if (rc)
1982 return rc;
1983
1984 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
1985 if (!pp)
1986 return -ENOMEM;
1987
1988 pp->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ * ATA_MAX_QUEUE,
1989 &pp->prd_dma, GFP_KERNEL);
1990 if (!pp->prd)
1991 return -ENOMEM;
1992 memset(pp->prd, 0, ATA_PRD_TBL_SZ * ATA_MAX_QUEUE);
1993
1994 ap->private_data = pp;
1995 pp->sactive_block = ap->ioaddr.scr_addr + 4 * SCR_ACTIVE;
1996 pp->irq_block = mmio + NV_INT_STATUS_MCP55 + ap->port_no * 2;
1997 pp->tag_block = mmio + NV_NCQ_REG_MCP55 + ap->port_no * 2;
1998
1999 return 0;
2000 }
2001
2002 static void nv_swncq_qc_prep(struct ata_queued_cmd *qc)
2003 {
2004 if (qc->tf.protocol != ATA_PROT_NCQ) {
2005 ata_sff_qc_prep(qc);
2006 return;
2007 }
2008
2009 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2010 return;
2011
2012 nv_swncq_fill_sg(qc);
2013 }
2014
2015 static void nv_swncq_fill_sg(struct ata_queued_cmd *qc)
2016 {
2017 struct ata_port *ap = qc->ap;
2018 struct scatterlist *sg;
2019 struct nv_swncq_port_priv *pp = ap->private_data;
2020 struct ata_prd *prd;
2021 unsigned int si, idx;
2022
2023 prd = pp->prd + ATA_MAX_PRD * qc->tag;
2024
2025 idx = 0;
2026 for_each_sg(qc->sg, sg, qc->n_elem, si) {
2027 u32 addr, offset;
2028 u32 sg_len, len;
2029
2030 addr = (u32)sg_dma_address(sg);
2031 sg_len = sg_dma_len(sg);
2032
2033 while (sg_len) {
2034 offset = addr & 0xffff;
2035 len = sg_len;
2036 if ((offset + sg_len) > 0x10000)
2037 len = 0x10000 - offset;
2038
2039 prd[idx].addr = cpu_to_le32(addr);
2040 prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2041
2042 idx++;
2043 sg_len -= len;
2044 addr += len;
2045 }
2046 }
2047
2048 prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2049 }
2050
2051 static unsigned int nv_swncq_issue_atacmd(struct ata_port *ap,
2052 struct ata_queued_cmd *qc)
2053 {
2054 struct nv_swncq_port_priv *pp = ap->private_data;
2055
2056 if (qc == NULL)
2057 return 0;
2058
2059 DPRINTK("Enter\n");
2060
2061 writel((1 << qc->tag), pp->sactive_block);
2062 pp->last_issue_tag = qc->tag;
2063 pp->dhfis_bits &= ~(1 << qc->tag);
2064 pp->dmafis_bits &= ~(1 << qc->tag);
2065 pp->qc_active |= (0x1 << qc->tag);
2066
2067 ap->ops->sff_tf_load(ap, &qc->tf); /* load tf registers */
2068 ap->ops->sff_exec_command(ap, &qc->tf);
2069
2070 DPRINTK("Issued tag %u\n", qc->tag);
2071
2072 return 0;
2073 }
2074
2075 static unsigned int nv_swncq_qc_issue(struct ata_queued_cmd *qc)
2076 {
2077 struct ata_port *ap = qc->ap;
2078 struct nv_swncq_port_priv *pp = ap->private_data;
2079
2080 if (qc->tf.protocol != ATA_PROT_NCQ)
2081 return ata_sff_qc_issue(qc);
2082
2083 DPRINTK("Enter\n");
2084
2085 if (!pp->qc_active)
2086 nv_swncq_issue_atacmd(ap, qc);
2087 else
2088 nv_swncq_qc_to_dq(ap, qc); /* add qc to defer queue */
2089
2090 return 0;
2091 }
2092
2093 static void nv_swncq_hotplug(struct ata_port *ap, u32 fis)
2094 {
2095 u32 serror;
2096 struct ata_eh_info *ehi = &ap->link.eh_info;
2097
2098 ata_ehi_clear_desc(ehi);
2099
2100 /* AHCI needs SError cleared; otherwise, it might lock up */
2101 sata_scr_read(&ap->link, SCR_ERROR, &serror);
2102 sata_scr_write(&ap->link, SCR_ERROR, serror);
2103
2104 /* analyze @irq_stat */
2105 if (fis & NV_SWNCQ_IRQ_ADDED)
2106 ata_ehi_push_desc(ehi, "hot plug");
2107 else if (fis & NV_SWNCQ_IRQ_REMOVED)
2108 ata_ehi_push_desc(ehi, "hot unplug");
2109
2110 ata_ehi_hotplugged(ehi);
2111
2112 /* okay, let's hand over to EH */
2113 ehi->serror |= serror;
2114
2115 ata_port_freeze(ap);
2116 }
2117
2118 static int nv_swncq_sdbfis(struct ata_port *ap)
2119 {
2120 struct ata_queued_cmd *qc;
2121 struct nv_swncq_port_priv *pp = ap->private_data;
2122 struct ata_eh_info *ehi = &ap->link.eh_info;
2123 u32 sactive;
2124 int nr_done = 0;
2125 u32 done_mask;
2126 int i;
2127 u8 host_stat;
2128 u8 lack_dhfis = 0;
2129
2130 host_stat = ap->ops->bmdma_status(ap);
2131 if (unlikely(host_stat & ATA_DMA_ERR)) {
2132 /* error when transfering data to/from memory */
2133 ata_ehi_clear_desc(ehi);
2134 ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
2135 ehi->err_mask |= AC_ERR_HOST_BUS;
2136 ehi->action |= ATA_EH_RESET;
2137 return -EINVAL;
2138 }
2139
2140 ap->ops->sff_irq_clear(ap);
2141 __ata_bmdma_stop(ap);
2142
2143 sactive = readl(pp->sactive_block);
2144 done_mask = pp->qc_active ^ sactive;
2145
2146 if (unlikely(done_mask & sactive)) {
2147 ata_ehi_clear_desc(ehi);
2148 ata_ehi_push_desc(ehi, "illegal SWNCQ:qc_active transition"
2149 "(%08x->%08x)", pp->qc_active, sactive);
2150 ehi->err_mask |= AC_ERR_HSM;
2151 ehi->action |= ATA_EH_RESET;
2152 return -EINVAL;
2153 }
2154 for (i = 0; i < ATA_MAX_QUEUE; i++) {
2155 if (!(done_mask & (1 << i)))
2156 continue;
2157
2158 qc = ata_qc_from_tag(ap, i);
2159 if (qc) {
2160 ata_qc_complete(qc);
2161 pp->qc_active &= ~(1 << i);
2162 pp->dhfis_bits &= ~(1 << i);
2163 pp->dmafis_bits &= ~(1 << i);
2164 pp->sdbfis_bits |= (1 << i);
2165 nr_done++;
2166 }
2167 }
2168
2169 if (!ap->qc_active) {
2170 DPRINTK("over\n");
2171 nv_swncq_pp_reinit(ap);
2172 return nr_done;
2173 }
2174
2175 if (pp->qc_active & pp->dhfis_bits)
2176 return nr_done;
2177
2178 if ((pp->ncq_flags & ncq_saw_backout) ||
2179 (pp->qc_active ^ pp->dhfis_bits))
2180 /* if the controller cann't get a device to host register FIS,
2181 * The driver needs to reissue the new command.
2182 */
2183 lack_dhfis = 1;
2184
2185 DPRINTK("id 0x%x QC: qc_active 0x%x,"
2186 "SWNCQ:qc_active 0x%X defer_bits %X "
2187 "dhfis 0x%X dmafis 0x%X last_issue_tag %x\n",
2188 ap->print_id, ap->qc_active, pp->qc_active,
2189 pp->defer_queue.defer_bits, pp->dhfis_bits,
2190 pp->dmafis_bits, pp->last_issue_tag);
2191
2192 nv_swncq_fis_reinit(ap);
2193
2194 if (lack_dhfis) {
2195 qc = ata_qc_from_tag(ap, pp->last_issue_tag);
2196 nv_swncq_issue_atacmd(ap, qc);
2197 return nr_done;
2198 }
2199
2200 if (pp->defer_queue.defer_bits) {
2201 /* send deferral queue command */
2202 qc = nv_swncq_qc_from_dq(ap);
2203 WARN_ON(qc == NULL);
2204 nv_swncq_issue_atacmd(ap, qc);
2205 }
2206
2207 return nr_done;
2208 }
2209
2210 static inline u32 nv_swncq_tag(struct ata_port *ap)
2211 {
2212 struct nv_swncq_port_priv *pp = ap->private_data;
2213 u32 tag;
2214
2215 tag = readb(pp->tag_block) >> 2;
2216 return (tag & 0x1f);
2217 }
2218
2219 static int nv_swncq_dmafis(struct ata_port *ap)
2220 {
2221 struct ata_queued_cmd *qc;
2222 unsigned int rw;
2223 u8 dmactl;
2224 u32 tag;
2225 struct nv_swncq_port_priv *pp = ap->private_data;
2226
2227 __ata_bmdma_stop(ap);
2228 tag = nv_swncq_tag(ap);
2229
2230 DPRINTK("dma setup tag 0x%x\n", tag);
2231 qc = ata_qc_from_tag(ap, tag);
2232
2233 if (unlikely(!qc))
2234 return 0;
2235
2236 rw = qc->tf.flags & ATA_TFLAG_WRITE;
2237
2238 /* load PRD table addr. */
2239 iowrite32(pp->prd_dma + ATA_PRD_TBL_SZ * qc->tag,
2240 ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
2241
2242 /* specify data direction, triple-check start bit is clear */
2243 dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2244 dmactl &= ~ATA_DMA_WR;
2245 if (!rw)
2246 dmactl |= ATA_DMA_WR;
2247
2248 iowrite8(dmactl | ATA_DMA_START, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2249
2250 return 1;
2251 }
2252
2253 static void nv_swncq_host_interrupt(struct ata_port *ap, u16 fis)
2254 {
2255 struct nv_swncq_port_priv *pp = ap->private_data;
2256 struct ata_queued_cmd *qc;
2257 struct ata_eh_info *ehi = &ap->link.eh_info;
2258 u32 serror;
2259 u8 ata_stat;
2260 int rc = 0;
2261
2262 ata_stat = ap->ops->sff_check_status(ap);
2263 nv_swncq_irq_clear(ap, fis);
2264 if (!fis)
2265 return;
2266
2267 if (ap->pflags & ATA_PFLAG_FROZEN)
2268 return;
2269
2270 if (fis & NV_SWNCQ_IRQ_HOTPLUG) {
2271 nv_swncq_hotplug(ap, fis);
2272 return;
2273 }
2274
2275 if (!pp->qc_active)
2276 return;
2277
2278 if (ap->ops->scr_read(&ap->link, SCR_ERROR, &serror))
2279 return;
2280 ap->ops->scr_write(&ap->link, SCR_ERROR, serror);
2281
2282 if (ata_stat & ATA_ERR) {
2283 ata_ehi_clear_desc(ehi);
2284 ata_ehi_push_desc(ehi, "Ata error. fis:0x%X", fis);
2285 ehi->err_mask |= AC_ERR_DEV;
2286 ehi->serror |= serror;
2287 ehi->action |= ATA_EH_RESET;
2288 ata_port_freeze(ap);
2289 return;
2290 }
2291
2292 if (fis & NV_SWNCQ_IRQ_BACKOUT) {
2293 /* If the IRQ is backout, driver must issue
2294 * the new command again some time later.
2295 */
2296 pp->ncq_flags |= ncq_saw_backout;
2297 }
2298
2299 if (fis & NV_SWNCQ_IRQ_SDBFIS) {
2300 pp->ncq_flags |= ncq_saw_sdb;
2301 DPRINTK("id 0x%x SWNCQ: qc_active 0x%X "
2302 "dhfis 0x%X dmafis 0x%X sactive 0x%X\n",
2303 ap->print_id, pp->qc_active, pp->dhfis_bits,
2304 pp->dmafis_bits, readl(pp->sactive_block));
2305 rc = nv_swncq_sdbfis(ap);
2306 if (rc < 0)
2307 goto irq_error;
2308 }
2309
2310 if (fis & NV_SWNCQ_IRQ_DHREGFIS) {
2311 /* The interrupt indicates the new command
2312 * was transmitted correctly to the drive.
2313 */
2314 pp->dhfis_bits |= (0x1 << pp->last_issue_tag);
2315 pp->ncq_flags |= ncq_saw_d2h;
2316 if (pp->ncq_flags & (ncq_saw_sdb | ncq_saw_backout)) {
2317 ata_ehi_push_desc(ehi, "illegal fis transaction");
2318 ehi->err_mask |= AC_ERR_HSM;
2319 ehi->action |= ATA_EH_RESET;
2320 goto irq_error;
2321 }
2322
2323 if (!(fis & NV_SWNCQ_IRQ_DMASETUP) &&
2324 !(pp->ncq_flags & ncq_saw_dmas)) {
2325 ata_stat = ap->ops->sff_check_status(ap);
2326 if (ata_stat & ATA_BUSY)
2327 goto irq_exit;
2328
2329 if (pp->defer_queue.defer_bits) {
2330 DPRINTK("send next command\n");
2331 qc = nv_swncq_qc_from_dq(ap);
2332 nv_swncq_issue_atacmd(ap, qc);
2333 }
2334 }
2335 }
2336
2337 if (fis & NV_SWNCQ_IRQ_DMASETUP) {
2338 /* program the dma controller with appropriate PRD buffers
2339 * and start the DMA transfer for requested command.
2340 */
2341 pp->dmafis_bits |= (0x1 << nv_swncq_tag(ap));
2342 pp->ncq_flags |= ncq_saw_dmas;
2343 rc = nv_swncq_dmafis(ap);
2344 }
2345
2346 irq_exit:
2347 return;
2348 irq_error:
2349 ata_ehi_push_desc(ehi, "fis:0x%x", fis);
2350 ata_port_freeze(ap);
2351 return;
2352 }
2353
2354 static irqreturn_t nv_swncq_interrupt(int irq, void *dev_instance)
2355 {
2356 struct ata_host *host = dev_instance;
2357 unsigned int i;
2358 unsigned int handled = 0;
2359 unsigned long flags;
2360 u32 irq_stat;
2361
2362 spin_lock_irqsave(&host->lock, flags);
2363
2364 irq_stat = readl(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_MCP55);
2365
2366 for (i = 0; i < host->n_ports; i++) {
2367 struct ata_port *ap = host->ports[i];
2368
2369 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) {
2370 if (ap->link.sactive) {
2371 nv_swncq_host_interrupt(ap, (u16)irq_stat);
2372 handled = 1;
2373 } else {
2374 if (irq_stat) /* reserve Hotplug */
2375 nv_swncq_irq_clear(ap, 0xfff0);
2376
2377 handled += nv_host_intr(ap, (u8)irq_stat);
2378 }
2379 }
2380 irq_stat >>= NV_INT_PORT_SHIFT_MCP55;
2381 }
2382
2383 spin_unlock_irqrestore(&host->lock, flags);
2384
2385 return IRQ_RETVAL(handled);
2386 }
2387
2388 static int nv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2389 {
2390 static int printed_version;
2391 const struct ata_port_info *ppi[] = { NULL, NULL };
2392 struct nv_pi_priv *ipriv;
2393 struct ata_host *host;
2394 struct nv_host_priv *hpriv;
2395 int rc;
2396 u32 bar;
2397 void __iomem *base;
2398 unsigned long type = ent->driver_data;
2399
2400 // Make sure this is a SATA controller by counting the number of bars
2401 // (NVIDIA SATA controllers will always have six bars). Otherwise,
2402 // it's an IDE controller and we ignore it.
2403 for (bar = 0; bar < 6; bar++)
2404 if (pci_resource_start(pdev, bar) == 0)
2405 return -ENODEV;
2406
2407 if (!printed_version++)
2408 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
2409
2410 rc = pcim_enable_device(pdev);
2411 if (rc)
2412 return rc;
2413
2414 /* determine type and allocate host */
2415 if (type == CK804 && adma_enabled) {
2416 dev_printk(KERN_NOTICE, &pdev->dev, "Using ADMA mode\n");
2417 type = ADMA;
2418 } else if (type == MCP5x && swncq_enabled) {
2419 dev_printk(KERN_NOTICE, &pdev->dev, "Using SWNCQ mode\n");
2420 type = SWNCQ;
2421 }
2422
2423 ppi[0] = &nv_port_info[type];
2424 ipriv = ppi[0]->private_data;
2425 rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
2426 if (rc)
2427 return rc;
2428
2429 hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
2430 if (!hpriv)
2431 return -ENOMEM;
2432 hpriv->type = type;
2433 host->private_data = hpriv;
2434
2435 /* request and iomap NV_MMIO_BAR */
2436 rc = pcim_iomap_regions(pdev, 1 << NV_MMIO_BAR, DRV_NAME);
2437 if (rc)
2438 return rc;
2439
2440 /* configure SCR access */
2441 base = host->iomap[NV_MMIO_BAR];
2442 host->ports[0]->ioaddr.scr_addr = base + NV_PORT0_SCR_REG_OFFSET;
2443 host->ports[1]->ioaddr.scr_addr = base + NV_PORT1_SCR_REG_OFFSET;
2444
2445 /* enable SATA space for CK804 */
2446 if (type >= CK804) {
2447 u8 regval;
2448
2449 pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
2450 regval |= NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
2451 pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
2452 }
2453
2454 /* init ADMA */
2455 if (type == ADMA) {
2456 rc = nv_adma_host_init(host);
2457 if (rc)
2458 return rc;
2459 } else if (type == SWNCQ)
2460 nv_swncq_host_init(host);
2461
2462 pci_set_master(pdev);
2463 return ata_host_activate(host, pdev->irq, ipriv->irq_handler,
2464 IRQF_SHARED, ipriv->sht);
2465 }
2466
2467 #ifdef CONFIG_PM
2468 static int nv_pci_device_resume(struct pci_dev *pdev)
2469 {
2470 struct ata_host *host = dev_get_drvdata(&pdev->dev);
2471 struct nv_host_priv *hpriv = host->private_data;
2472 int rc;
2473
2474 rc = ata_pci_device_do_resume(pdev);
2475 if (rc)
2476 return rc;
2477
2478 if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2479 if (hpriv->type >= CK804) {
2480 u8 regval;
2481
2482 pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
2483 regval |= NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
2484 pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
2485 }
2486 if (hpriv->type == ADMA) {
2487 u32 tmp32;
2488 struct nv_adma_port_priv *pp;
2489 /* enable/disable ADMA on the ports appropriately */
2490 pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
2491
2492 pp = host->ports[0]->private_data;
2493 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
2494 tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT0_EN |
2495 NV_MCP_SATA_CFG_20_PORT0_PWB_EN);
2496 else
2497 tmp32 |= (NV_MCP_SATA_CFG_20_PORT0_EN |
2498 NV_MCP_SATA_CFG_20_PORT0_PWB_EN);
2499 pp = host->ports[1]->private_data;
2500 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE)
2501 tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT1_EN |
2502 NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
2503 else
2504 tmp32 |= (NV_MCP_SATA_CFG_20_PORT1_EN |
2505 NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
2506
2507 pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
2508 }
2509 }
2510
2511 ata_host_resume(host);
2512
2513 return 0;
2514 }
2515 #endif
2516
2517 static void nv_ck804_host_stop(struct ata_host *host)
2518 {
2519 struct pci_dev *pdev = to_pci_dev(host->dev);
2520 u8 regval;
2521
2522 /* disable SATA space for CK804 */
2523 pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
2524 regval &= ~NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
2525 pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
2526 }
2527
2528 static void nv_adma_host_stop(struct ata_host *host)
2529 {
2530 struct pci_dev *pdev = to_pci_dev(host->dev);
2531 u32 tmp32;
2532
2533 /* disable ADMA on the ports */
2534 pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &tmp32);
2535 tmp32 &= ~(NV_MCP_SATA_CFG_20_PORT0_EN |
2536 NV_MCP_SATA_CFG_20_PORT0_PWB_EN |
2537 NV_MCP_SATA_CFG_20_PORT1_EN |
2538 NV_MCP_SATA_CFG_20_PORT1_PWB_EN);
2539
2540 pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, tmp32);
2541
2542 nv_ck804_host_stop(host);
2543 }
2544
2545 static int __init nv_init(void)
2546 {
2547 return pci_register_driver(&nv_pci_driver);
2548 }
2549
2550 static void __exit nv_exit(void)
2551 {
2552 pci_unregister_driver(&nv_pci_driver);
2553 }
2554
2555 module_init(nv_init);
2556 module_exit(nv_exit);
2557 module_param_named(adma, adma_enabled, bool, 0444);
2558 MODULE_PARM_DESC(adma, "Enable use of ADMA (Default: false)");
2559 module_param_named(swncq, swncq_enabled, bool, 0444);
2560 MODULE_PARM_DESC(swncq, "Enable use of SWNCQ (Default: true)");
2561
linux-next