blob: 030665ba76b73a308fd0e35693742140b761792c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * sata_promise.c - Promise SATA
3 *
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
Mikael Pettersson5595ddf2007-10-30 14:21:55 +01005 * Mikael Pettersson <mikpe@it.uu.se>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Please ALWAYS copy linux-ide@vger.kernel.org
7 * on emails.
8 *
9 * Copyright 2003-2004 Red Hat, Inc.
10 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 *
Jeff Garzikaf36d7f2005-08-28 20:18:39 -040012 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 *
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
29 *
30 * Hardware information only available under NDA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 *
32 */
33
34#include <linux/kernel.h>
35#include <linux/module.h>
36#include <linux/pci.h>
37#include <linux/init.h>
38#include <linux/blkdev.h>
39#include <linux/delay.h>
40#include <linux/interrupt.h>
Jeff Garzika9524a72005-10-30 14:39:11 -050041#include <linux/device.h>
Mikael Pettersson95006182007-01-09 10:51:46 +010042#include <scsi/scsi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <scsi/scsi_host.h>
Jeff Garzik193515d2005-11-07 00:59:37 -050044#include <scsi/scsi_cmnd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/libata.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include "sata_promise.h"
47
48#define DRV_NAME "sata_promise"
Mikael Petterssonc07a9c42008-03-23 18:41:01 +010049#define DRV_VERSION "2.12"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51enum {
Tejun Heoeca25dc2007-04-17 23:44:07 +090052 PDC_MAX_PORTS = 4,
Tejun Heo0d5ff562007-02-01 15:06:36 +090053 PDC_MMIO_BAR = 3,
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +010054 PDC_MAX_PRD = LIBATA_MAX_PRD - 1, /* -1 for ASIC PRD bug workaround */
Tejun Heo0d5ff562007-02-01 15:06:36 +090055
Mikael Pettersson821d22c2008-05-17 18:48:15 +020056 /* host register offsets (from host->iomap[PDC_MMIO_BAR]) */
57 PDC_INT_SEQMASK = 0x40, /* Mask of asserted SEQ INTs */
58 PDC_FLASH_CTL = 0x44, /* Flash control register */
59 PDC_SATA_PLUG_CSR = 0x6C, /* SATA Plug control/status reg */
60 PDC2_SATA_PLUG_CSR = 0x60, /* SATAII Plug control/status reg */
61 PDC_TBG_MODE = 0x41C, /* TBG mode (not SATAII) */
62 PDC_SLEW_CTL = 0x470, /* slew rate control reg (not SATAII) */
63
64 /* per-port ATA register offsets (from ap->ioaddr.cmd_addr) */
Mikael Pettersson95006182007-01-09 10:51:46 +010065 PDC_FEATURE = 0x04, /* Feature/Error reg (per port) */
66 PDC_SECTOR_COUNT = 0x08, /* Sector count reg (per port) */
67 PDC_SECTOR_NUMBER = 0x0C, /* Sector number reg (per port) */
68 PDC_CYLINDER_LOW = 0x10, /* Cylinder low reg (per port) */
69 PDC_CYLINDER_HIGH = 0x14, /* Cylinder high reg (per port) */
70 PDC_DEVICE = 0x18, /* Device/Head reg (per port) */
71 PDC_COMMAND = 0x1C, /* Command/status reg (per port) */
Mikael Pettersson73fd4562007-01-10 09:32:34 +010072 PDC_ALTSTATUS = 0x38, /* Alternate-status/device-control reg (per port) */
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 PDC_PKT_SUBMIT = 0x40, /* Command packet pointer addr */
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 PDC_GLOBAL_CTL = 0x48, /* Global control/status (per port) */
75 PDC_CTLSTAT = 0x60, /* IDE control and status (per port) */
Mikael Pettersson821d22c2008-05-17 18:48:15 +020076
77 /* per-port SATA register offsets (from ap->ioaddr.scr_addr) */
78 PDC_PHYMODE4 = 0x14,
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Mikael Pettersson176efb02007-03-14 09:51:35 +010080 /* PDC_GLOBAL_CTL bit definitions */
81 PDC_PH_ERR = (1 << 8), /* PCI error while loading packet */
82 PDC_SH_ERR = (1 << 9), /* PCI error while loading S/G table */
83 PDC_DH_ERR = (1 << 10), /* PCI error while loading data */
84 PDC2_HTO_ERR = (1 << 12), /* host bus timeout */
85 PDC2_ATA_HBA_ERR = (1 << 13), /* error during SATA DATA FIS transmission */
86 PDC2_ATA_DMA_CNT_ERR = (1 << 14), /* DMA DATA FIS size differs from S/G count */
87 PDC_OVERRUN_ERR = (1 << 19), /* S/G byte count larger than HD requires */
88 PDC_UNDERRUN_ERR = (1 << 20), /* S/G byte count less than HD requires */
89 PDC_DRIVE_ERR = (1 << 21), /* drive error */
90 PDC_PCI_SYS_ERR = (1 << 22), /* PCI system error */
91 PDC1_PCI_PARITY_ERR = (1 << 23), /* PCI parity error (from SATA150 driver) */
92 PDC1_ERR_MASK = PDC1_PCI_PARITY_ERR,
Jeff Garzik5796d1c2007-10-26 00:03:37 -040093 PDC2_ERR_MASK = PDC2_HTO_ERR | PDC2_ATA_HBA_ERR |
94 PDC2_ATA_DMA_CNT_ERR,
95 PDC_ERR_MASK = PDC_PH_ERR | PDC_SH_ERR | PDC_DH_ERR |
96 PDC_OVERRUN_ERR | PDC_UNDERRUN_ERR |
97 PDC_DRIVE_ERR | PDC_PCI_SYS_ERR |
98 PDC1_ERR_MASK | PDC2_ERR_MASK,
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100 board_2037x = 0, /* FastTrak S150 TX2plus */
Tejun Heoeca25dc2007-04-17 23:44:07 +0900101 board_2037x_pata = 1, /* FastTrak S150 TX2plus PATA port */
102 board_20319 = 2, /* FastTrak S150 TX4 */
103 board_20619 = 3, /* FastTrak TX4000 */
104 board_2057x = 4, /* SATAII150 Tx2plus */
Mikael Petterssond0e58032007-06-19 21:53:30 +0200105 board_2057x_pata = 5, /* SATAII150 Tx2plus PATA port */
Tejun Heoeca25dc2007-04-17 23:44:07 +0900106 board_40518 = 6, /* SATAII150 Tx4 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Luke Kosewski6340f012006-01-28 12:39:29 -0500108 PDC_HAS_PATA = (1 << 1), /* PDC20375/20575 has PATA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Mikael Pettersson95006182007-01-09 10:51:46 +0100110 /* Sequence counter control registers bit definitions */
111 PDC_SEQCNTRL_INT_MASK = (1 << 5), /* Sequence Interrupt Mask */
112
113 /* Feature register values */
114 PDC_FEATURE_ATAPI_PIO = 0x00, /* ATAPI data xfer by PIO */
115 PDC_FEATURE_ATAPI_DMA = 0x01, /* ATAPI data xfer by DMA */
116
117 /* Device/Head register values */
118 PDC_DEVICE_SATA = 0xE0, /* Device/Head value for SATA devices */
119
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100120 /* PDC_CTLSTAT bit definitions */
121 PDC_DMA_ENABLE = (1 << 7),
122 PDC_IRQ_DISABLE = (1 << 10),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 PDC_RESET = (1 << 11), /* HDMA reset */
Jeff Garzik50630192005-12-13 02:29:45 -0500124
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100125 PDC_COMMON_FLAGS = ATA_FLAG_NO_LEGACY |
Mikael Pettersson95006182007-01-09 10:51:46 +0100126 ATA_FLAG_MMIO |
Jeff Garzik3d0a59c2005-12-13 22:28:19 -0500127 ATA_FLAG_PIO_POLLING,
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +0100128
Tejun Heoeca25dc2007-04-17 23:44:07 +0900129 /* ap->flags bits */
130 PDC_FLAG_GEN_II = (1 << 24),
131 PDC_FLAG_SATA_PATA = (1 << 25), /* supports SATA + PATA */
132 PDC_FLAG_4_PORTS = (1 << 26), /* 4 ports */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133};
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135struct pdc_port_priv {
136 u8 *pkt;
137 dma_addr_t pkt_dma;
138};
139
Tejun Heoda3dbb12007-07-16 14:29:40 +0900140static int pdc_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
141static int pdc_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
Mikael Pettersson7715a6f2008-05-17 18:49:09 +0200142static int pdc_ata_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
Tejun Heoeca25dc2007-04-17 23:44:07 +0900143static int pdc_common_port_start(struct ata_port *ap);
144static int pdc_sata_port_start(struct ata_port *ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145static void pdc_qc_prep(struct ata_queued_cmd *qc);
Jeff Garzik057ace52005-10-22 14:27:05 -0400146static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
147static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
Mikael Pettersson95006182007-01-09 10:51:46 +0100148static int pdc_check_atapi_dma(struct ata_queued_cmd *qc);
Mikael Pettersson724114a2007-03-11 21:20:43 +0100149static int pdc_old_sata_check_atapi_dma(struct ata_queued_cmd *qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150static void pdc_irq_clear(struct ata_port *ap);
Tejun Heo9363c382008-04-07 22:47:16 +0900151static unsigned int pdc_qc_issue(struct ata_queued_cmd *qc);
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100152static void pdc_freeze(struct ata_port *ap);
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100153static void pdc_sata_freeze(struct ata_port *ap);
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100154static void pdc_thaw(struct ata_port *ap);
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100155static void pdc_sata_thaw(struct ata_port *ap);
Tejun Heoa1efdab2008-03-25 12:22:50 +0900156static void pdc_error_handler(struct ata_port *ap);
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100157static void pdc_post_internal_cmd(struct ata_queued_cmd *qc);
Mikael Pettersson724114a2007-03-11 21:20:43 +0100158static int pdc_pata_cable_detect(struct ata_port *ap);
159static int pdc_sata_cable_detect(struct ata_port *ap);
Jeff Garzik374b1872005-08-30 05:42:52 -0400160
Jeff Garzik193515d2005-11-07 00:59:37 -0500161static struct scsi_host_template pdc_ata_sht = {
Tejun Heo68d1d072008-03-25 12:22:49 +0900162 ATA_BASE_SHT(DRV_NAME),
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100163 .sg_tablesize = PDC_MAX_PRD,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 .dma_boundary = ATA_DMA_BOUNDARY,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165};
166
Tejun Heo029cfd62008-03-25 12:22:49 +0900167static const struct ata_port_operations pdc_common_ops = {
168 .inherits = &ata_sff_port_ops,
Mikael Pettersson95006182007-01-09 10:51:46 +0100169
Tejun Heo5682ed32008-04-07 22:47:16 +0900170 .sff_tf_load = pdc_tf_load_mmio,
171 .sff_exec_command = pdc_exec_command_mmio,
Tejun Heo029cfd62008-03-25 12:22:49 +0900172 .check_atapi_dma = pdc_check_atapi_dma,
Mikael Pettersson95006182007-01-09 10:51:46 +0100173 .qc_prep = pdc_qc_prep,
Tejun Heo9363c382008-04-07 22:47:16 +0900174 .qc_issue = pdc_qc_issue,
Tejun Heo5682ed32008-04-07 22:47:16 +0900175 .sff_irq_clear = pdc_irq_clear,
Tejun Heo029cfd62008-03-25 12:22:49 +0900176
177 .post_internal_cmd = pdc_post_internal_cmd,
Tejun Heoa1efdab2008-03-25 12:22:50 +0900178 .error_handler = pdc_error_handler,
Tejun Heo029cfd62008-03-25 12:22:49 +0900179};
180
181static struct ata_port_operations pdc_sata_ops = {
182 .inherits = &pdc_common_ops,
183 .cable_detect = pdc_sata_cable_detect,
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100184 .freeze = pdc_sata_freeze,
185 .thaw = pdc_sata_thaw,
Mikael Pettersson95006182007-01-09 10:51:46 +0100186 .scr_read = pdc_sata_scr_read,
187 .scr_write = pdc_sata_scr_write,
Tejun Heoeca25dc2007-04-17 23:44:07 +0900188 .port_start = pdc_sata_port_start,
Mikael Pettersson95006182007-01-09 10:51:46 +0100189};
190
191/* First-generation chips need a more restrictive ->check_atapi_dma op */
Tejun Heo029cfd62008-03-25 12:22:49 +0900192static struct ata_port_operations pdc_old_sata_ops = {
193 .inherits = &pdc_sata_ops,
Mikael Pettersson724114a2007-03-11 21:20:43 +0100194 .check_atapi_dma = pdc_old_sata_check_atapi_dma,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195};
196
Tejun Heo029cfd62008-03-25 12:22:49 +0900197static struct ata_port_operations pdc_pata_ops = {
198 .inherits = &pdc_common_ops,
199 .cable_detect = pdc_pata_cable_detect,
Mikael Pettersson53873732007-02-11 23:19:53 +0100200 .freeze = pdc_freeze,
201 .thaw = pdc_thaw,
Tejun Heoeca25dc2007-04-17 23:44:07 +0900202 .port_start = pdc_common_port_start,
Jeff Garzik2cba5822005-08-29 05:12:30 -0400203};
204
Arjan van de Ven98ac62d2005-11-28 10:06:23 +0100205static const struct ata_port_info pdc_port_info[] = {
Mikael Pettersson5595ddf2007-10-30 14:21:55 +0100206 [board_2037x] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 {
Tejun Heoeca25dc2007-04-17 23:44:07 +0900208 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
209 PDC_FLAG_SATA_PATA,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 .pio_mask = 0x1f, /* pio0-4 */
211 .mwdma_mask = 0x07, /* mwdma0-2 */
Jeff Garzik469248a2007-07-08 01:13:16 -0400212 .udma_mask = ATA_UDMA6,
Mikael Pettersson95006182007-01-09 10:51:46 +0100213 .port_ops = &pdc_old_sata_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 },
215
Mikael Pettersson5595ddf2007-10-30 14:21:55 +0100216 [board_2037x_pata] =
Tejun Heoeca25dc2007-04-17 23:44:07 +0900217 {
218 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS,
219 .pio_mask = 0x1f, /* pio0-4 */
220 .mwdma_mask = 0x07, /* mwdma0-2 */
Jeff Garzik469248a2007-07-08 01:13:16 -0400221 .udma_mask = ATA_UDMA6,
Tejun Heoeca25dc2007-04-17 23:44:07 +0900222 .port_ops = &pdc_pata_ops,
223 },
224
Mikael Pettersson5595ddf2007-10-30 14:21:55 +0100225 [board_20319] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 {
Tejun Heoeca25dc2007-04-17 23:44:07 +0900227 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
228 PDC_FLAG_4_PORTS,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 .pio_mask = 0x1f, /* pio0-4 */
230 .mwdma_mask = 0x07, /* mwdma0-2 */
Jeff Garzik469248a2007-07-08 01:13:16 -0400231 .udma_mask = ATA_UDMA6,
Mikael Pettersson95006182007-01-09 10:51:46 +0100232 .port_ops = &pdc_old_sata_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 },
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400234
Mikael Pettersson5595ddf2007-10-30 14:21:55 +0100235 [board_20619] =
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400236 {
Tejun Heoeca25dc2007-04-17 23:44:07 +0900237 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS |
238 PDC_FLAG_4_PORTS,
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400239 .pio_mask = 0x1f, /* pio0-4 */
240 .mwdma_mask = 0x07, /* mwdma0-2 */
Jeff Garzik469248a2007-07-08 01:13:16 -0400241 .udma_mask = ATA_UDMA6,
Jeff Garzik2cba5822005-08-29 05:12:30 -0400242 .port_ops = &pdc_pata_ops,
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400243 },
Yusuf Iskenderoglu5a46fe82006-01-17 08:06:21 -0500244
Mikael Pettersson5595ddf2007-10-30 14:21:55 +0100245 [board_2057x] =
Luke Kosewski6340f012006-01-28 12:39:29 -0500246 {
Tejun Heoeca25dc2007-04-17 23:44:07 +0900247 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
248 PDC_FLAG_GEN_II | PDC_FLAG_SATA_PATA,
Luke Kosewski6340f012006-01-28 12:39:29 -0500249 .pio_mask = 0x1f, /* pio0-4 */
250 .mwdma_mask = 0x07, /* mwdma0-2 */
Jeff Garzik469248a2007-07-08 01:13:16 -0400251 .udma_mask = ATA_UDMA6,
Luke Kosewski6340f012006-01-28 12:39:29 -0500252 .port_ops = &pdc_sata_ops,
253 },
254
Mikael Pettersson5595ddf2007-10-30 14:21:55 +0100255 [board_2057x_pata] =
Tejun Heoeca25dc2007-04-17 23:44:07 +0900256 {
Jeff Garzikbb312232007-05-24 23:35:59 -0400257 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS |
Tejun Heoeca25dc2007-04-17 23:44:07 +0900258 PDC_FLAG_GEN_II,
259 .pio_mask = 0x1f, /* pio0-4 */
260 .mwdma_mask = 0x07, /* mwdma0-2 */
Jeff Garzik469248a2007-07-08 01:13:16 -0400261 .udma_mask = ATA_UDMA6,
Tejun Heoeca25dc2007-04-17 23:44:07 +0900262 .port_ops = &pdc_pata_ops,
263 },
264
Mikael Pettersson5595ddf2007-10-30 14:21:55 +0100265 [board_40518] =
Luke Kosewski6340f012006-01-28 12:39:29 -0500266 {
Tejun Heoeca25dc2007-04-17 23:44:07 +0900267 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA |
268 PDC_FLAG_GEN_II | PDC_FLAG_4_PORTS,
Luke Kosewski6340f012006-01-28 12:39:29 -0500269 .pio_mask = 0x1f, /* pio0-4 */
270 .mwdma_mask = 0x07, /* mwdma0-2 */
Jeff Garzik469248a2007-07-08 01:13:16 -0400271 .udma_mask = ATA_UDMA6,
Luke Kosewski6340f012006-01-28 12:39:29 -0500272 .port_ops = &pdc_sata_ops,
273 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274};
275
Jeff Garzik3b7d6972005-11-10 11:04:11 -0500276static const struct pci_device_id pdc_ata_pci_tbl[] = {
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400277 { PCI_VDEVICE(PROMISE, 0x3371), board_2037x },
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400278 { PCI_VDEVICE(PROMISE, 0x3373), board_2037x },
279 { PCI_VDEVICE(PROMISE, 0x3375), board_2037x },
280 { PCI_VDEVICE(PROMISE, 0x3376), board_2037x },
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +0100281 { PCI_VDEVICE(PROMISE, 0x3570), board_2057x },
282 { PCI_VDEVICE(PROMISE, 0x3571), board_2057x },
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400283 { PCI_VDEVICE(PROMISE, 0x3574), board_2057x },
Mikael Petterssond324d4622006-12-06 09:55:43 +0100284 { PCI_VDEVICE(PROMISE, 0x3577), board_2057x },
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +0100285 { PCI_VDEVICE(PROMISE, 0x3d73), board_2057x },
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400286 { PCI_VDEVICE(PROMISE, 0x3d75), board_2057x },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400288 { PCI_VDEVICE(PROMISE, 0x3318), board_20319 },
289 { PCI_VDEVICE(PROMISE, 0x3319), board_20319 },
Mikael Pettersson7f9992a2007-08-29 10:25:37 +0200290 { PCI_VDEVICE(PROMISE, 0x3515), board_40518 },
291 { PCI_VDEVICE(PROMISE, 0x3519), board_40518 },
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +0100292 { PCI_VDEVICE(PROMISE, 0x3d17), board_40518 },
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400293 { PCI_VDEVICE(PROMISE, 0x3d18), board_40518 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400295 { PCI_VDEVICE(PROMISE, 0x6629), board_20619 },
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 { } /* terminate list */
298};
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300static struct pci_driver pdc_ata_pci_driver = {
301 .name = DRV_NAME,
302 .id_table = pdc_ata_pci_tbl,
303 .probe = pdc_ata_init_one,
304 .remove = ata_pci_remove_one,
305};
306
Mikael Pettersson724114a2007-03-11 21:20:43 +0100307static int pdc_common_port_start(struct ata_port *ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
Jeff Garzikcca39742006-08-24 03:19:22 -0400309 struct device *dev = ap->host->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 struct pdc_port_priv *pp;
311 int rc;
312
313 rc = ata_port_start(ap);
314 if (rc)
315 return rc;
316
Tejun Heo24dc5f32007-01-20 16:00:28 +0900317 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
318 if (!pp)
319 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320
Tejun Heo24dc5f32007-01-20 16:00:28 +0900321 pp->pkt = dmam_alloc_coherent(dev, 128, &pp->pkt_dma, GFP_KERNEL);
322 if (!pp->pkt)
323 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325 ap->private_data = pp;
326
Mikael Pettersson724114a2007-03-11 21:20:43 +0100327 return 0;
328}
329
330static int pdc_sata_port_start(struct ata_port *ap)
331{
Mikael Pettersson724114a2007-03-11 21:20:43 +0100332 int rc;
333
334 rc = pdc_common_port_start(ap);
335 if (rc)
336 return rc;
337
Mikael Pettersson599b7202006-12-01 10:55:58 +0100338 /* fix up PHYMODE4 align timing */
Tejun Heoeca25dc2007-04-17 23:44:07 +0900339 if (ap->flags & PDC_FLAG_GEN_II) {
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200340 void __iomem *sata_mmio = ap->ioaddr.scr_addr;
Mikael Pettersson599b7202006-12-01 10:55:58 +0100341 unsigned int tmp;
342
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200343 tmp = readl(sata_mmio + PDC_PHYMODE4);
Mikael Pettersson599b7202006-12-01 10:55:58 +0100344 tmp = (tmp & ~3) | 1; /* set bits 1:0 = 0:1 */
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200345 writel(tmp, sata_mmio + PDC_PHYMODE4);
Mikael Pettersson599b7202006-12-01 10:55:58 +0100346 }
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351static void pdc_reset_port(struct ata_port *ap)
352{
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200353 void __iomem *ata_ctlstat_mmio = ap->ioaddr.cmd_addr + PDC_CTLSTAT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 unsigned int i;
355 u32 tmp;
356
357 for (i = 11; i > 0; i--) {
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200358 tmp = readl(ata_ctlstat_mmio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (tmp & PDC_RESET)
360 break;
361
362 udelay(100);
363
364 tmp |= PDC_RESET;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200365 writel(tmp, ata_ctlstat_mmio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 }
367
368 tmp &= ~PDC_RESET;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200369 writel(tmp, ata_ctlstat_mmio);
370 readl(ata_ctlstat_mmio); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
Mikael Pettersson724114a2007-03-11 21:20:43 +0100373static int pdc_pata_cable_detect(struct ata_port *ap)
Jeff Garzikd3fb4e82006-05-24 01:43:25 -0400374{
375 u8 tmp;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200376 void __iomem *ata_mmio = ap->ioaddr.cmd_addr;
Jeff Garzikd3fb4e82006-05-24 01:43:25 -0400377
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200378 tmp = readb(ata_mmio + PDC_CTLSTAT + 3);
Mikael Pettersson724114a2007-03-11 21:20:43 +0100379 if (tmp & 0x01)
380 return ATA_CBL_PATA40;
381 return ATA_CBL_PATA80;
382}
383
384static int pdc_sata_cable_detect(struct ata_port *ap)
385{
Alan Coxe2a97522007-03-08 23:06:47 +0000386 return ATA_CBL_SATA;
Jeff Garzikd3fb4e82006-05-24 01:43:25 -0400387}
388
Tejun Heoda3dbb12007-07-16 14:29:40 +0900389static int pdc_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390{
Mikael Pettersson724114a2007-03-11 21:20:43 +0100391 if (sc_reg > SCR_CONTROL)
Tejun Heoda3dbb12007-07-16 14:29:40 +0900392 return -EINVAL;
393 *val = readl(ap->ioaddr.scr_addr + (sc_reg * 4));
394 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395}
396
Tejun Heoda3dbb12007-07-16 14:29:40 +0900397static int pdc_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398{
Mikael Pettersson724114a2007-03-11 21:20:43 +0100399 if (sc_reg > SCR_CONTROL)
Tejun Heoda3dbb12007-07-16 14:29:40 +0900400 return -EINVAL;
Tejun Heo0d5ff562007-02-01 15:06:36 +0900401 writel(val, ap->ioaddr.scr_addr + (sc_reg * 4));
Tejun Heoda3dbb12007-07-16 14:29:40 +0900402 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403}
404
Mikael Petterssonfba6edb2007-01-13 21:32:30 +0100405static void pdc_atapi_pkt(struct ata_queued_cmd *qc)
Mikael Pettersson95006182007-01-09 10:51:46 +0100406{
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100407 struct ata_port *ap = qc->ap;
408 dma_addr_t sg_table = ap->prd_dma;
409 unsigned int cdb_len = qc->dev->cdb_len;
410 u8 *cdb = qc->cdb;
411 struct pdc_port_priv *pp = ap->private_data;
412 u8 *buf = pp->pkt;
Al Viro826cd152008-03-25 05:18:11 +0000413 __le32 *buf32 = (__le32 *) buf;
Tejun Heo46a67142007-12-04 13:33:30 +0900414 unsigned int dev_sel, feature;
Mikael Pettersson95006182007-01-09 10:51:46 +0100415
416 /* set control bits (byte 0), zero delay seq id (byte 3),
417 * and seq id (byte 2)
418 */
Mikael Petterssonfba6edb2007-01-13 21:32:30 +0100419 switch (qc->tf.protocol) {
Tejun Heo0dc36882007-12-18 16:34:43 -0500420 case ATAPI_PROT_DMA:
Mikael Petterssonfba6edb2007-01-13 21:32:30 +0100421 if (!(qc->tf.flags & ATA_TFLAG_WRITE))
422 buf32[0] = cpu_to_le32(PDC_PKT_READ);
423 else
424 buf32[0] = 0;
425 break;
Tejun Heo0dc36882007-12-18 16:34:43 -0500426 case ATAPI_PROT_NODATA:
Mikael Petterssonfba6edb2007-01-13 21:32:30 +0100427 buf32[0] = cpu_to_le32(PDC_PKT_NODATA);
428 break;
429 default:
430 BUG();
431 break;
432 }
Mikael Pettersson95006182007-01-09 10:51:46 +0100433 buf32[1] = cpu_to_le32(sg_table); /* S/G table addr */
434 buf32[2] = 0; /* no next-packet */
435
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100436 /* select drive */
Tejun Heo46a67142007-12-04 13:33:30 +0900437 if (sata_scr_valid(&ap->link))
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100438 dev_sel = PDC_DEVICE_SATA;
Tejun Heo46a67142007-12-04 13:33:30 +0900439 else
440 dev_sel = qc->tf.device;
441
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100442 buf[12] = (1 << 5) | ATA_REG_DEVICE;
443 buf[13] = dev_sel;
444 buf[14] = (1 << 5) | ATA_REG_DEVICE | PDC_PKT_CLEAR_BSY;
445 buf[15] = dev_sel; /* once more, waiting for BSY to clear */
446
447 buf[16] = (1 << 5) | ATA_REG_NSECT;
Tejun Heo46a67142007-12-04 13:33:30 +0900448 buf[17] = qc->tf.nsect;
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100449 buf[18] = (1 << 5) | ATA_REG_LBAL;
Tejun Heo46a67142007-12-04 13:33:30 +0900450 buf[19] = qc->tf.lbal;
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100451
452 /* set feature and byte counter registers */
Tejun Heo0dc36882007-12-18 16:34:43 -0500453 if (qc->tf.protocol != ATAPI_PROT_DMA)
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100454 feature = PDC_FEATURE_ATAPI_PIO;
Tejun Heo46a67142007-12-04 13:33:30 +0900455 else
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100456 feature = PDC_FEATURE_ATAPI_DMA;
Tejun Heo46a67142007-12-04 13:33:30 +0900457
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100458 buf[20] = (1 << 5) | ATA_REG_FEATURE;
459 buf[21] = feature;
460 buf[22] = (1 << 5) | ATA_REG_BYTEL;
Tejun Heo46a67142007-12-04 13:33:30 +0900461 buf[23] = qc->tf.lbam;
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100462 buf[24] = (1 << 5) | ATA_REG_BYTEH;
Tejun Heo46a67142007-12-04 13:33:30 +0900463 buf[25] = qc->tf.lbah;
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100464
465 /* send ATAPI packet command 0xA0 */
466 buf[26] = (1 << 5) | ATA_REG_CMD;
Tejun Heo46a67142007-12-04 13:33:30 +0900467 buf[27] = qc->tf.command;
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100468
469 /* select drive and check DRQ */
470 buf[28] = (1 << 5) | ATA_REG_DEVICE | PDC_PKT_WAIT_DRDY;
471 buf[29] = dev_sel;
472
Mikael Pettersson95006182007-01-09 10:51:46 +0100473 /* we can represent cdb lengths 2/4/6/8/10/12/14/16 */
474 BUG_ON(cdb_len & ~0x1E);
475
Mikael Pettersson4113bb62007-01-13 21:31:05 +0100476 /* append the CDB as the final part */
477 buf[30] = (((cdb_len >> 1) & 7) << 5) | ATA_REG_DATA | PDC_LAST_REG;
478 memcpy(buf+31, cdb, cdb_len);
Mikael Pettersson95006182007-01-09 10:51:46 +0100479}
480
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100481/**
482 * pdc_fill_sg - Fill PCI IDE PRD table
483 * @qc: Metadata associated with taskfile to be transferred
484 *
485 * Fill PCI IDE PRD (scatter-gather) table with segments
486 * associated with the current disk command.
487 * Make sure hardware does not choke on it.
488 *
489 * LOCKING:
490 * spin_lock_irqsave(host lock)
491 *
492 */
493static void pdc_fill_sg(struct ata_queued_cmd *qc)
494{
495 struct ata_port *ap = qc->ap;
496 struct scatterlist *sg;
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100497 const u32 SG_COUNT_ASIC_BUG = 41*4;
Tejun Heoff2aeb12007-12-05 16:43:11 +0900498 unsigned int si, idx;
499 u32 len;
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100500
501 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
502 return;
503
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100504 idx = 0;
Tejun Heoff2aeb12007-12-05 16:43:11 +0900505 for_each_sg(qc->sg, sg, qc->n_elem, si) {
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100506 u32 addr, offset;
Harvey Harrison6903c0f2008-02-13 21:14:08 -0800507 u32 sg_len;
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100508
509 /* determine if physical DMA addr spans 64K boundary.
510 * Note h/w doesn't support 64-bit, so we unconditionally
511 * truncate dma_addr_t to u32.
512 */
513 addr = (u32) sg_dma_address(sg);
514 sg_len = sg_dma_len(sg);
515
516 while (sg_len) {
517 offset = addr & 0xffff;
518 len = sg_len;
519 if ((offset + sg_len) > 0x10000)
520 len = 0x10000 - offset;
521
522 ap->prd[idx].addr = cpu_to_le32(addr);
523 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
524 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
525
526 idx++;
527 sg_len -= len;
528 addr += len;
529 }
530 }
531
Tejun Heoff2aeb12007-12-05 16:43:11 +0900532 len = le32_to_cpu(ap->prd[idx - 1].flags_len);
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100533
Tejun Heoff2aeb12007-12-05 16:43:11 +0900534 if (len > SG_COUNT_ASIC_BUG) {
535 u32 addr;
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100536
Tejun Heoff2aeb12007-12-05 16:43:11 +0900537 VPRINTK("Splitting last PRD.\n");
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100538
Tejun Heoff2aeb12007-12-05 16:43:11 +0900539 addr = le32_to_cpu(ap->prd[idx - 1].addr);
540 ap->prd[idx - 1].flags_len = cpu_to_le32(len - SG_COUNT_ASIC_BUG);
541 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx - 1, addr, SG_COUNT_ASIC_BUG);
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100542
Tejun Heoff2aeb12007-12-05 16:43:11 +0900543 addr = addr + len - SG_COUNT_ASIC_BUG;
544 len = SG_COUNT_ASIC_BUG;
545 ap->prd[idx].addr = cpu_to_le32(addr);
546 ap->prd[idx].flags_len = cpu_to_le32(len);
547 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100548
Tejun Heoff2aeb12007-12-05 16:43:11 +0900549 idx++;
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100550 }
Tejun Heoff2aeb12007-12-05 16:43:11 +0900551
552 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100553}
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555static void pdc_qc_prep(struct ata_queued_cmd *qc)
556{
557 struct pdc_port_priv *pp = qc->ap->private_data;
558 unsigned int i;
559
560 VPRINTK("ENTER\n");
561
562 switch (qc->tf.protocol) {
563 case ATA_PROT_DMA:
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100564 pdc_fill_sg(qc);
Mikael Pettersson7715a6f2008-05-17 18:49:09 +0200565 /*FALLTHROUGH*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 case ATA_PROT_NODATA:
567 i = pdc_pkt_header(&qc->tf, qc->ap->prd_dma,
568 qc->dev->devno, pp->pkt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 if (qc->tf.flags & ATA_TFLAG_LBA48)
570 i = pdc_prep_lba48(&qc->tf, pp->pkt, i);
571 else
572 i = pdc_prep_lba28(&qc->tf, pp->pkt, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 pdc_pkt_footer(&qc->tf, pp->pkt, i);
574 break;
Tejun Heo0dc36882007-12-18 16:34:43 -0500575 case ATAPI_PROT_PIO:
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100576 pdc_fill_sg(qc);
Mikael Pettersson95006182007-01-09 10:51:46 +0100577 break;
Tejun Heo0dc36882007-12-18 16:34:43 -0500578 case ATAPI_PROT_DMA:
Mikael Petterssonb9ccd4a2007-10-30 14:20:49 +0100579 pdc_fill_sg(qc);
Mikael Petterssonfba6edb2007-01-13 21:32:30 +0100580 /*FALLTHROUGH*/
Tejun Heo0dc36882007-12-18 16:34:43 -0500581 case ATAPI_PROT_NODATA:
Mikael Petterssonfba6edb2007-01-13 21:32:30 +0100582 pdc_atapi_pkt(qc);
Mikael Pettersson95006182007-01-09 10:51:46 +0100583 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 default:
585 break;
586 }
587}
588
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100589static int pdc_is_sataii_tx4(unsigned long flags)
590{
591 const unsigned long mask = PDC_FLAG_GEN_II | PDC_FLAG_4_PORTS;
592 return (flags & mask) == mask;
593}
594
595static unsigned int pdc_port_no_to_ata_no(unsigned int port_no,
596 int is_sataii_tx4)
597{
598 static const unsigned char sataii_tx4_port_remap[4] = { 3, 1, 0, 2};
599 return is_sataii_tx4 ? sataii_tx4_port_remap[port_no] : port_no;
600}
601
602static unsigned int pdc_sata_nr_ports(const struct ata_port *ap)
603{
604 return (ap->flags & PDC_FLAG_4_PORTS) ? 4 : 2;
605}
606
607static unsigned int pdc_sata_ata_port_to_ata_no(const struct ata_port *ap)
608{
609 const struct ata_host *host = ap->host;
610 unsigned int nr_ports = pdc_sata_nr_ports(ap);
611 unsigned int i;
612
Mikael Pettersson7715a6f2008-05-17 18:49:09 +0200613 for (i = 0; i < nr_ports && host->ports[i] != ap; ++i)
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100614 ;
615 BUG_ON(i >= nr_ports);
616 return pdc_port_no_to_ata_no(i, pdc_is_sataii_tx4(ap->flags));
617}
618
619static unsigned int pdc_sata_hotplug_offset(const struct ata_port *ap)
620{
621 return (ap->flags & PDC_FLAG_GEN_II) ? PDC2_SATA_PLUG_CSR : PDC_SATA_PLUG_CSR;
622}
623
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100624static void pdc_freeze(struct ata_port *ap)
625{
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200626 void __iomem *ata_mmio = ap->ioaddr.cmd_addr;
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100627 u32 tmp;
628
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200629 tmp = readl(ata_mmio + PDC_CTLSTAT);
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100630 tmp |= PDC_IRQ_DISABLE;
631 tmp &= ~PDC_DMA_ENABLE;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200632 writel(tmp, ata_mmio + PDC_CTLSTAT);
633 readl(ata_mmio + PDC_CTLSTAT); /* flush */
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100634}
635
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100636static void pdc_sata_freeze(struct ata_port *ap)
637{
638 struct ata_host *host = ap->host;
639 void __iomem *host_mmio = host->iomap[PDC_MMIO_BAR];
640 unsigned int hotplug_offset = pdc_sata_hotplug_offset(ap);
641 unsigned int ata_no = pdc_sata_ata_port_to_ata_no(ap);
642 u32 hotplug_status;
643
644 /* Disable hotplug events on this port.
645 *
646 * Locking:
647 * 1) hotplug register accesses must be serialised via host->lock
648 * 2) ap->lock == &ap->host->lock
649 * 3) ->freeze() and ->thaw() are called with ap->lock held
650 */
651 hotplug_status = readl(host_mmio + hotplug_offset);
652 hotplug_status |= 0x11 << (ata_no + 16);
653 writel(hotplug_status, host_mmio + hotplug_offset);
654 readl(host_mmio + hotplug_offset); /* flush */
655
656 pdc_freeze(ap);
657}
658
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100659static void pdc_thaw(struct ata_port *ap)
660{
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200661 void __iomem *ata_mmio = ap->ioaddr.cmd_addr;
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100662 u32 tmp;
663
664 /* clear IRQ */
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200665 readl(ata_mmio + PDC_COMMAND);
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100666
667 /* turn IRQ back on */
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200668 tmp = readl(ata_mmio + PDC_CTLSTAT);
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100669 tmp &= ~PDC_IRQ_DISABLE;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200670 writel(tmp, ata_mmio + PDC_CTLSTAT);
671 readl(ata_mmio + PDC_CTLSTAT); /* flush */
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100672}
673
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100674static void pdc_sata_thaw(struct ata_port *ap)
675{
676 struct ata_host *host = ap->host;
677 void __iomem *host_mmio = host->iomap[PDC_MMIO_BAR];
678 unsigned int hotplug_offset = pdc_sata_hotplug_offset(ap);
679 unsigned int ata_no = pdc_sata_ata_port_to_ata_no(ap);
680 u32 hotplug_status;
681
682 pdc_thaw(ap);
683
684 /* Enable hotplug events on this port.
685 * Locking: see pdc_sata_freeze().
686 */
687 hotplug_status = readl(host_mmio + hotplug_offset);
688 hotplug_status |= 0x11 << ata_no;
689 hotplug_status &= ~(0x11 << (ata_no + 16));
690 writel(hotplug_status, host_mmio + hotplug_offset);
691 readl(host_mmio + hotplug_offset); /* flush */
692}
693
Tejun Heoa1efdab2008-03-25 12:22:50 +0900694static void pdc_error_handler(struct ata_port *ap)
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100695{
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100696 if (!(ap->pflags & ATA_PFLAG_FROZEN))
697 pdc_reset_port(ap);
698
Tejun Heoa1efdab2008-03-25 12:22:50 +0900699 ata_std_error_handler(ap);
Mikael Pettersson724114a2007-03-11 21:20:43 +0100700}
701
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100702static void pdc_post_internal_cmd(struct ata_queued_cmd *qc)
703{
704 struct ata_port *ap = qc->ap;
705
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100706 /* make DMA engine forget about the failed command */
Tejun Heoa51d6442007-03-20 15:24:11 +0900707 if (qc->flags & ATA_QCFLAG_FAILED)
Mikael Pettersson25b93d82006-12-07 00:06:51 +0100708 pdc_reset_port(ap);
709}
710
Mikael Pettersson176efb02007-03-14 09:51:35 +0100711static void pdc_error_intr(struct ata_port *ap, struct ata_queued_cmd *qc,
712 u32 port_status, u32 err_mask)
713{
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900714 struct ata_eh_info *ehi = &ap->link.eh_info;
Mikael Pettersson176efb02007-03-14 09:51:35 +0100715 unsigned int ac_err_mask = 0;
716
717 ata_ehi_clear_desc(ehi);
718 ata_ehi_push_desc(ehi, "port_status 0x%08x", port_status);
719 port_status &= err_mask;
720
721 if (port_status & PDC_DRIVE_ERR)
722 ac_err_mask |= AC_ERR_DEV;
723 if (port_status & (PDC_OVERRUN_ERR | PDC_UNDERRUN_ERR))
724 ac_err_mask |= AC_ERR_HSM;
725 if (port_status & (PDC2_ATA_HBA_ERR | PDC2_ATA_DMA_CNT_ERR))
726 ac_err_mask |= AC_ERR_ATA_BUS;
727 if (port_status & (PDC_PH_ERR | PDC_SH_ERR | PDC_DH_ERR | PDC2_HTO_ERR
728 | PDC_PCI_SYS_ERR | PDC1_PCI_PARITY_ERR))
729 ac_err_mask |= AC_ERR_HOST_BUS;
730
Tejun Heo936fd732007-08-06 18:36:23 +0900731 if (sata_scr_valid(&ap->link)) {
Tejun Heoda3dbb12007-07-16 14:29:40 +0900732 u32 serror;
733
734 pdc_sata_scr_read(ap, SCR_ERROR, &serror);
735 ehi->serror |= serror;
736 }
Mikael Petterssonce2d3ab2007-04-07 14:29:51 +0200737
Mikael Pettersson176efb02007-03-14 09:51:35 +0100738 qc->err_mask |= ac_err_mask;
Mikael Petterssonce2d3ab2007-04-07 14:29:51 +0200739
740 pdc_reset_port(ap);
Mikael Pettersson8ffcfd92007-05-06 22:12:31 +0200741
742 ata_port_abort(ap);
Mikael Pettersson176efb02007-03-14 09:51:35 +0100743}
744
Mikael Pettersson7715a6f2008-05-17 18:49:09 +0200745static unsigned int pdc_host_intr(struct ata_port *ap,
746 struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747{
Albert Leea22e2eb2005-12-05 15:38:02 +0800748 unsigned int handled = 0;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200749 void __iomem *ata_mmio = ap->ioaddr.cmd_addr;
Mikael Pettersson176efb02007-03-14 09:51:35 +0100750 u32 port_status, err_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Mikael Pettersson176efb02007-03-14 09:51:35 +0100752 err_mask = PDC_ERR_MASK;
Tejun Heoeca25dc2007-04-17 23:44:07 +0900753 if (ap->flags & PDC_FLAG_GEN_II)
Mikael Pettersson176efb02007-03-14 09:51:35 +0100754 err_mask &= ~PDC1_ERR_MASK;
755 else
756 err_mask &= ~PDC2_ERR_MASK;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200757 port_status = readl(ata_mmio + PDC_GLOBAL_CTL);
Mikael Pettersson176efb02007-03-14 09:51:35 +0100758 if (unlikely(port_status & err_mask)) {
759 pdc_error_intr(ap, qc, port_status, err_mask);
760 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
762
763 switch (qc->tf.protocol) {
764 case ATA_PROT_DMA:
765 case ATA_PROT_NODATA:
Tejun Heo0dc36882007-12-18 16:34:43 -0500766 case ATAPI_PROT_DMA:
767 case ATAPI_PROT_NODATA:
Albert Leea22e2eb2005-12-05 15:38:02 +0800768 qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
769 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 handled = 1;
771 break;
Mikael Petterssond0e58032007-06-19 21:53:30 +0200772 default:
Albert Leeee500aa2005-09-27 17:34:38 +0800773 ap->stats.idle_irq++;
774 break;
Mikael Petterssond0e58032007-06-19 21:53:30 +0200775 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Albert Leeee500aa2005-09-27 17:34:38 +0800777 return handled;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778}
779
780static void pdc_irq_clear(struct ata_port *ap)
781{
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200782 void __iomem *ata_mmio = ap->ioaddr.cmd_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200784 readl(ata_mmio + PDC_COMMAND);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785}
786
Jeff Garzik5796d1c2007-10-26 00:03:37 -0400787static irqreturn_t pdc_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
Jeff Garzikcca39742006-08-24 03:19:22 -0400789 struct ata_host *host = dev_instance;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 struct ata_port *ap;
791 u32 mask = 0;
792 unsigned int i, tmp;
793 unsigned int handled = 0;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200794 void __iomem *host_mmio;
Mikael Petterssona77720a2007-07-03 01:09:05 +0200795 unsigned int hotplug_offset, ata_no;
796 u32 hotplug_status;
797 int is_sataii_tx4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
799 VPRINTK("ENTER\n");
800
Tejun Heo0d5ff562007-02-01 15:06:36 +0900801 if (!host || !host->iomap[PDC_MMIO_BAR]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 VPRINTK("QUICK EXIT\n");
803 return IRQ_NONE;
804 }
805
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200806 host_mmio = host->iomap[PDC_MMIO_BAR];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100808 spin_lock(&host->lock);
809
Mikael Petterssona77720a2007-07-03 01:09:05 +0200810 /* read and clear hotplug flags for all ports */
811 if (host->ports[0]->flags & PDC_FLAG_GEN_II)
812 hotplug_offset = PDC2_SATA_PLUG_CSR;
813 else
814 hotplug_offset = PDC_SATA_PLUG_CSR;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200815 hotplug_status = readl(host_mmio + hotplug_offset);
Mikael Petterssona77720a2007-07-03 01:09:05 +0200816 if (hotplug_status & 0xff)
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200817 writel(hotplug_status | 0xff, host_mmio + hotplug_offset);
Mikael Petterssona77720a2007-07-03 01:09:05 +0200818 hotplug_status &= 0xff; /* clear uninteresting bits */
819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 /* reading should also clear interrupts */
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200821 mask = readl(host_mmio + PDC_INT_SEQMASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
Mikael Petterssona77720a2007-07-03 01:09:05 +0200823 if (mask == 0xffffffff && hotplug_status == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 VPRINTK("QUICK EXIT 2\n");
Mikael Petterssonc07a9c42008-03-23 18:41:01 +0100825 goto done_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 }
Luke Kosewski6340f012006-01-28 12:39:29 -0500827
Mikael Pettersson7715a6f2008-05-17 18:49:09 +0200828 mask &= 0xffff; /* only 16 SEQIDs possible */
Mikael Petterssona77720a2007-07-03 01:09:05 +0200829 if (mask == 0 && hotplug_status == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 VPRINTK("QUICK EXIT 3\n");
Luke Kosewski6340f012006-01-28 12:39:29 -0500831 goto done_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 }
833
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200834 writel(mask, host_mmio + PDC_INT_SEQMASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Mikael Petterssona77720a2007-07-03 01:09:05 +0200836 is_sataii_tx4 = pdc_is_sataii_tx4(host->ports[0]->flags);
837
Jeff Garzikcca39742006-08-24 03:19:22 -0400838 for (i = 0; i < host->n_ports; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 VPRINTK("port %u\n", i);
Jeff Garzikcca39742006-08-24 03:19:22 -0400840 ap = host->ports[i];
Mikael Petterssona77720a2007-07-03 01:09:05 +0200841
842 /* check for a plug or unplug event */
843 ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4);
844 tmp = hotplug_status & (0x11 << ata_no);
845 if (tmp && ap &&
846 !(ap->flags & ATA_FLAG_DISABLED)) {
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900847 struct ata_eh_info *ehi = &ap->link.eh_info;
Mikael Petterssona77720a2007-07-03 01:09:05 +0200848 ata_ehi_clear_desc(ehi);
849 ata_ehi_hotplugged(ehi);
850 ata_ehi_push_desc(ehi, "hotplug_status %#x", tmp);
851 ata_port_freeze(ap);
852 ++handled;
853 continue;
854 }
855
856 /* check for a packet interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 tmp = mask & (1 << (i + 1));
Tejun Heoc1389502005-08-22 14:59:24 +0900858 if (tmp && ap &&
Jeff Garzik029f5462006-04-02 10:30:40 -0400859 !(ap->flags & ATA_FLAG_DISABLED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 struct ata_queued_cmd *qc;
861
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900862 qc = ata_qc_from_tag(ap, ap->link.active_tag);
Albert Leee50362e2005-09-27 17:39:50 +0800863 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 handled += pdc_host_intr(ap, qc);
865 }
866 }
867
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 VPRINTK("EXIT\n");
869
Luke Kosewski6340f012006-01-28 12:39:29 -0500870done_irq:
Jeff Garzikcca39742006-08-24 03:19:22 -0400871 spin_unlock(&host->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 return IRQ_RETVAL(handled);
873}
874
Mikael Pettersson7715a6f2008-05-17 18:49:09 +0200875static void pdc_packet_start(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876{
877 struct ata_port *ap = qc->ap;
878 struct pdc_port_priv *pp = ap->private_data;
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200879 void __iomem *host_mmio = ap->host->iomap[PDC_MMIO_BAR];
880 void __iomem *ata_mmio = ap->ioaddr.cmd_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 unsigned int port_no = ap->port_no;
882 u8 seq = (u8) (port_no + 1);
883
884 VPRINTK("ENTER, ap %p\n", ap);
885
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200886 writel(0x00000001, host_mmio + (seq * 4));
887 readl(host_mmio + (seq * 4)); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
889 pp->pkt[2] = seq;
890 wmb(); /* flush PRD, pkt writes */
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200891 writel(pp->pkt_dma, ata_mmio + PDC_PKT_SUBMIT);
892 readl(ata_mmio + PDC_PKT_SUBMIT); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893}
894
Tejun Heo9363c382008-04-07 22:47:16 +0900895static unsigned int pdc_qc_issue(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896{
897 switch (qc->tf.protocol) {
Tejun Heo0dc36882007-12-18 16:34:43 -0500898 case ATAPI_PROT_NODATA:
Mikael Petterssonfba6edb2007-01-13 21:32:30 +0100899 if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
900 break;
901 /*FALLTHROUGH*/
Tejun Heo51b94d22007-06-08 13:46:55 -0700902 case ATA_PROT_NODATA:
903 if (qc->tf.flags & ATA_TFLAG_POLLING)
904 break;
905 /*FALLTHROUGH*/
Tejun Heo0dc36882007-12-18 16:34:43 -0500906 case ATAPI_PROT_DMA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 case ATA_PROT_DMA:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 pdc_packet_start(qc);
909 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 default:
911 break;
912 }
Tejun Heo9363c382008-04-07 22:47:16 +0900913 return ata_sff_qc_issue(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914}
915
Jeff Garzik057ace52005-10-22 14:27:05 -0400916static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
Tejun Heo0dc36882007-12-18 16:34:43 -0500918 WARN_ON(tf->protocol == ATA_PROT_DMA || tf->protocol == ATAPI_PROT_DMA);
Tejun Heo9363c382008-04-07 22:47:16 +0900919 ata_sff_tf_load(ap, tf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920}
921
Jeff Garzik5796d1c2007-10-26 00:03:37 -0400922static void pdc_exec_command_mmio(struct ata_port *ap,
923 const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924{
Tejun Heo0dc36882007-12-18 16:34:43 -0500925 WARN_ON(tf->protocol == ATA_PROT_DMA || tf->protocol == ATAPI_PROT_DMA);
Tejun Heo9363c382008-04-07 22:47:16 +0900926 ata_sff_exec_command(ap, tf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
Mikael Pettersson95006182007-01-09 10:51:46 +0100929static int pdc_check_atapi_dma(struct ata_queued_cmd *qc)
930{
931 u8 *scsicmd = qc->scsicmd->cmnd;
932 int pio = 1; /* atapi dma off by default */
933
934 /* Whitelist commands that may use DMA. */
935 switch (scsicmd[0]) {
936 case WRITE_12:
937 case WRITE_10:
938 case WRITE_6:
939 case READ_12:
940 case READ_10:
941 case READ_6:
942 case 0xad: /* READ_DVD_STRUCTURE */
943 case 0xbe: /* READ_CD */
944 pio = 0;
945 }
946 /* -45150 (FFFF4FA2) to -1 (FFFFFFFF) shall use PIO mode */
947 if (scsicmd[0] == WRITE_10) {
Jeff Garzik5796d1c2007-10-26 00:03:37 -0400948 unsigned int lba =
949 (scsicmd[2] << 24) |
950 (scsicmd[3] << 16) |
951 (scsicmd[4] << 8) |
952 scsicmd[5];
Mikael Pettersson95006182007-01-09 10:51:46 +0100953 if (lba >= 0xFFFF4FA2)
954 pio = 1;
955 }
956 return pio;
957}
958
Mikael Pettersson724114a2007-03-11 21:20:43 +0100959static int pdc_old_sata_check_atapi_dma(struct ata_queued_cmd *qc)
Mikael Pettersson95006182007-01-09 10:51:46 +0100960{
Mikael Pettersson95006182007-01-09 10:51:46 +0100961 /* First generation chips cannot use ATAPI DMA on SATA ports */
Mikael Pettersson724114a2007-03-11 21:20:43 +0100962 return 1;
Mikael Pettersson95006182007-01-09 10:51:46 +0100963}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
Tejun Heoeca25dc2007-04-17 23:44:07 +0900965static void pdc_ata_setup_port(struct ata_port *ap,
966 void __iomem *base, void __iomem *scr_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967{
Tejun Heoeca25dc2007-04-17 23:44:07 +0900968 ap->ioaddr.cmd_addr = base;
969 ap->ioaddr.data_addr = base;
970 ap->ioaddr.feature_addr =
971 ap->ioaddr.error_addr = base + 0x4;
972 ap->ioaddr.nsect_addr = base + 0x8;
973 ap->ioaddr.lbal_addr = base + 0xc;
974 ap->ioaddr.lbam_addr = base + 0x10;
975 ap->ioaddr.lbah_addr = base + 0x14;
976 ap->ioaddr.device_addr = base + 0x18;
977 ap->ioaddr.command_addr =
978 ap->ioaddr.status_addr = base + 0x1c;
979 ap->ioaddr.altstatus_addr =
980 ap->ioaddr.ctl_addr = base + 0x38;
981 ap->ioaddr.scr_addr = scr_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982}
983
Tejun Heoeca25dc2007-04-17 23:44:07 +0900984static void pdc_host_init(struct ata_host *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985{
Mikael Pettersson821d22c2008-05-17 18:48:15 +0200986 void __iomem *host_mmio = host->iomap[PDC_MMIO_BAR];
Tejun Heoeca25dc2007-04-17 23:44:07 +0900987 int is_gen2 = host->ports[0]->flags & PDC_FLAG_GEN_II;
Mikael Petterssond324d4622006-12-06 09:55:43 +0100988 int hotplug_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 u32 tmp;
990
Tejun Heoeca25dc2007-04-17 23:44:07 +0900991 if (is_gen2)
Mikael Petterssond324d4622006-12-06 09:55:43 +0100992 hotplug_offset = PDC2_SATA_PLUG_CSR;
993 else
994 hotplug_offset = PDC_SATA_PLUG_CSR;
995
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 /*
997 * Except for the hotplug stuff, this is voodoo from the
998 * Promise driver. Label this entire section
999 * "TODO: figure out why we do this"
1000 */
1001
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +01001002 /* enable BMR_BURST, maybe change FIFO_SHD to 8 dwords */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001003 tmp = readl(host_mmio + PDC_FLASH_CTL);
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +01001004 tmp |= 0x02000; /* bit 13 (enable bmr burst) */
Tejun Heoeca25dc2007-04-17 23:44:07 +09001005 if (!is_gen2)
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +01001006 tmp |= 0x10000; /* bit 16 (fifo threshold at 8 dw) */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001007 writel(tmp, host_mmio + PDC_FLASH_CTL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
1009 /* clear plug/unplug flags for all ports */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001010 tmp = readl(host_mmio + hotplug_offset);
1011 writel(tmp | 0xff, host_mmio + hotplug_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
Mikael Petterssona77720a2007-07-03 01:09:05 +02001013 /* unmask plug/unplug ints */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001014 tmp = readl(host_mmio + hotplug_offset);
1015 writel(tmp & ~0xff0000, host_mmio + hotplug_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +01001017 /* don't initialise TBG or SLEW on 2nd generation chips */
Tejun Heoeca25dc2007-04-17 23:44:07 +09001018 if (is_gen2)
Mikael Petterssonb2d1eee2006-11-22 22:00:15 +01001019 return;
1020
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 /* reduce TBG clock to 133 Mhz. */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001022 tmp = readl(host_mmio + PDC_TBG_MODE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 tmp &= ~0x30000; /* clear bit 17, 16*/
1024 tmp |= 0x10000; /* set bit 17:16 = 0:1 */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001025 writel(tmp, host_mmio + PDC_TBG_MODE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001027 readl(host_mmio + PDC_TBG_MODE); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 msleep(10);
1029
1030 /* adjust slew rate control register. */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001031 tmp = readl(host_mmio + PDC_SLEW_CTL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 tmp &= 0xFFFFF03F; /* clear bit 11 ~ 6 */
1033 tmp |= 0x00000900; /* set bit 11-9 = 100b , bit 8-6 = 100 */
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001034 writel(tmp, host_mmio + PDC_SLEW_CTL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035}
1036
Jeff Garzik5796d1c2007-10-26 00:03:37 -04001037static int pdc_ata_init_one(struct pci_dev *pdev,
1038 const struct pci_device_id *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039{
1040 static int printed_version;
Tejun Heoeca25dc2007-04-17 23:44:07 +09001041 const struct ata_port_info *pi = &pdc_port_info[ent->driver_data];
1042 const struct ata_port_info *ppi[PDC_MAX_PORTS];
1043 struct ata_host *host;
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001044 void __iomem *host_mmio;
Tejun Heoeca25dc2007-04-17 23:44:07 +09001045 int n_ports, i, rc;
Mikael Pettersson5ac2fe52007-05-06 22:14:01 +02001046 int is_sataii_tx4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
1048 if (!printed_version++)
Jeff Garzika9524a72005-10-30 14:39:11 -05001049 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
Tejun Heoeca25dc2007-04-17 23:44:07 +09001051 /* enable and acquire resources */
Tejun Heo24dc5f32007-01-20 16:00:28 +09001052 rc = pcim_enable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (rc)
1054 return rc;
1055
Tejun Heo0d5ff562007-02-01 15:06:36 +09001056 rc = pcim_iomap_regions(pdev, 1 << PDC_MMIO_BAR, DRV_NAME);
1057 if (rc == -EBUSY)
Tejun Heo24dc5f32007-01-20 16:00:28 +09001058 pcim_pin_device(pdev);
Tejun Heo0d5ff562007-02-01 15:06:36 +09001059 if (rc)
Tejun Heo24dc5f32007-01-20 16:00:28 +09001060 return rc;
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001061 host_mmio = pcim_iomap_table(pdev)[PDC_MMIO_BAR];
Tejun Heoeca25dc2007-04-17 23:44:07 +09001062
1063 /* determine port configuration and setup host */
1064 n_ports = 2;
1065 if (pi->flags & PDC_FLAG_4_PORTS)
1066 n_ports = 4;
1067 for (i = 0; i < n_ports; i++)
1068 ppi[i] = pi;
1069
1070 if (pi->flags & PDC_FLAG_SATA_PATA) {
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001071 u8 tmp = readb(host_mmio + PDC_FLASH_CTL + 1);
Mikael Petterssond0e58032007-06-19 21:53:30 +02001072 if (!(tmp & 0x80))
Tejun Heoeca25dc2007-04-17 23:44:07 +09001073 ppi[n_ports++] = pi + 1;
Tejun Heoeca25dc2007-04-17 23:44:07 +09001074 }
1075
1076 host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
1077 if (!host) {
1078 dev_printk(KERN_ERR, &pdev->dev, "failed to allocate host\n");
1079 return -ENOMEM;
1080 }
1081 host->iomap = pcim_iomap_table(pdev);
1082
Mikael Petterssond0e58032007-06-19 21:53:30 +02001083 is_sataii_tx4 = pdc_is_sataii_tx4(pi->flags);
Mikael Pettersson5ac2fe52007-05-06 22:14:01 +02001084 for (i = 0; i < host->n_ports; i++) {
Tejun Heocbcdd872007-08-18 13:14:55 +09001085 struct ata_port *ap = host->ports[i];
Mikael Petterssond0e58032007-06-19 21:53:30 +02001086 unsigned int ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4);
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001087 unsigned int ata_offset = 0x200 + ata_no * 0x80;
Tejun Heocbcdd872007-08-18 13:14:55 +09001088 unsigned int scr_offset = 0x400 + ata_no * 0x100;
1089
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001090 pdc_ata_setup_port(ap, host_mmio + ata_offset, host_mmio + scr_offset);
Tejun Heocbcdd872007-08-18 13:14:55 +09001091
1092 ata_port_pbar_desc(ap, PDC_MMIO_BAR, -1, "mmio");
Mikael Pettersson821d22c2008-05-17 18:48:15 +02001093 ata_port_pbar_desc(ap, PDC_MMIO_BAR, ata_offset, "ata");
Mikael Pettersson5ac2fe52007-05-06 22:14:01 +02001094 }
Tejun Heoeca25dc2007-04-17 23:44:07 +09001095
1096 /* initialize adapter */
1097 pdc_host_init(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
1099 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
1100 if (rc)
Tejun Heo24dc5f32007-01-20 16:00:28 +09001101 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
1103 if (rc)
Tejun Heo24dc5f32007-01-20 16:00:28 +09001104 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
Tejun Heoeca25dc2007-04-17 23:44:07 +09001106 /* start host, request IRQ and attach */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 pci_set_master(pdev);
Tejun Heoeca25dc2007-04-17 23:44:07 +09001108 return ata_host_activate(host, pdev->irq, pdc_interrupt, IRQF_SHARED,
1109 &pdc_ata_sht);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110}
1111
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112static int __init pdc_ata_init(void)
1113{
Pavel Roskinb7887192006-08-10 18:13:18 +09001114 return pci_register_driver(&pdc_ata_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115}
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117static void __exit pdc_ata_exit(void)
1118{
1119 pci_unregister_driver(&pdc_ata_pci_driver);
1120}
1121
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122MODULE_AUTHOR("Jeff Garzik");
Tobias Lorenzf497ba72005-05-12 15:51:01 -04001123MODULE_DESCRIPTION("Promise ATA TX2/TX4/TX4000 low-level driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124MODULE_LICENSE("GPL");
1125MODULE_DEVICE_TABLE(pci, pdc_ata_pci_tbl);
1126MODULE_VERSION(DRV_VERSION);
1127
1128module_init(pdc_ata_init);
1129module_exit(pdc_ata_exit);