blob: 9c4389b5689a6cfc0861af8eece4989e4bfe5615 [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>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2003-2004 Red Hat, Inc.
9 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
Jeff Garzikaf36d7f2005-08-28 20:18:39 -040011 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 *
26 * libata documentation is available via 'make {ps|pdf}docs',
27 * as Documentation/DocBook/libata.*
28 *
29 * Hardware information only available under NDA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 *
31 */
32
33#include <linux/kernel.h>
34#include <linux/module.h>
35#include <linux/pci.h>
36#include <linux/init.h>
37#include <linux/blkdev.h>
38#include <linux/delay.h>
39#include <linux/interrupt.h>
40#include <linux/sched.h>
Jeff Garzika9524a72005-10-30 14:39:11 -050041#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <scsi/scsi_host.h>
Jeff Garzik193515d2005-11-07 00:59:37 -050043#include <scsi/scsi_cmnd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/libata.h>
45#include <asm/io.h>
46#include "sata_promise.h"
47
48#define DRV_NAME "sata_promise"
Jeff Garzik46b027c2006-11-14 14:46:17 -050049#define DRV_VERSION "1.05"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51
52enum {
53 PDC_PKT_SUBMIT = 0x40, /* Command packet pointer addr */
54 PDC_INT_SEQMASK = 0x40, /* Mask of asserted SEQ INTs */
Jeff Garzik46b027c2006-11-14 14:46:17 -050055 PDC_TBG_MODE = 0x41C, /* TBG mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 PDC_FLASH_CTL = 0x44, /* Flash control register */
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 PDC_GLOBAL_CTL = 0x48, /* Global control/status (per port) */
58 PDC_CTLSTAT = 0x60, /* IDE control and status (per port) */
59 PDC_SATA_PLUG_CSR = 0x6C, /* SATA Plug control/status reg */
Luke Kosewski6340f012006-01-28 12:39:29 -050060 PDC2_SATA_PLUG_CSR = 0x60, /* SATAII Plug control/status reg */
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 PDC_SLEW_CTL = 0x470, /* slew rate control reg */
62
63 PDC_ERR_MASK = (1<<19) | (1<<20) | (1<<21) | (1<<22) |
64 (1<<8) | (1<<9) | (1<<10),
65
66 board_2037x = 0, /* FastTrak S150 TX2plus */
67 board_20319 = 1, /* FastTrak S150 TX4 */
Tobias Lorenzf497ba72005-05-12 15:51:01 -040068 board_20619 = 2, /* FastTrak TX4000 */
Yusuf Iskenderoglu5a46fe82006-01-17 08:06:21 -050069 board_20771 = 3, /* FastTrak TX2300 */
Luke Kosewski6340f012006-01-28 12:39:29 -050070 board_2057x = 4, /* SATAII150 Tx2plus */
71 board_40518 = 5, /* SATAII150 Tx4 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Luke Kosewski6340f012006-01-28 12:39:29 -050073 PDC_HAS_PATA = (1 << 1), /* PDC20375/20575 has PATA */
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75 PDC_RESET = (1 << 11), /* HDMA reset */
Jeff Garzik50630192005-12-13 02:29:45 -050076
77 PDC_COMMON_FLAGS = ATA_FLAG_NO_LEGACY | ATA_FLAG_SRST |
Jeff Garzik3d0a59c2005-12-13 22:28:19 -050078 ATA_FLAG_MMIO | ATA_FLAG_NO_ATAPI |
79 ATA_FLAG_PIO_POLLING,
Linus Torvalds1da177e2005-04-16 15:20:36 -070080};
81
82
83struct pdc_port_priv {
84 u8 *pkt;
85 dma_addr_t pkt_dma;
86};
87
Luke Kosewski6340f012006-01-28 12:39:29 -050088struct pdc_host_priv {
89 int hotplug_offset;
90};
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg);
93static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
94static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
David Howells7d12e782006-10-05 14:55:46 +010095static irqreturn_t pdc_interrupt (int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096static void pdc_eng_timeout(struct ata_port *ap);
97static int pdc_port_start(struct ata_port *ap);
98static void pdc_port_stop(struct ata_port *ap);
Jeff Garzik2cba5822005-08-29 05:12:30 -040099static void pdc_pata_phy_reset(struct ata_port *ap);
100static void pdc_sata_phy_reset(struct ata_port *ap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101static void pdc_qc_prep(struct ata_queued_cmd *qc);
Jeff Garzik057ace52005-10-22 14:27:05 -0400102static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
103static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104static void pdc_irq_clear(struct ata_port *ap);
Tejun Heo9a3d9eb2006-01-23 13:09:36 +0900105static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc);
Jeff Garzikcca39742006-08-24 03:19:22 -0400106static void pdc_host_stop(struct ata_host *host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Jeff Garzik374b1872005-08-30 05:42:52 -0400108
Jeff Garzik193515d2005-11-07 00:59:37 -0500109static struct scsi_host_template pdc_ata_sht = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 .module = THIS_MODULE,
111 .name = DRV_NAME,
112 .ioctl = ata_scsi_ioctl,
113 .queuecommand = ata_scsi_queuecmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 .can_queue = ATA_DEF_QUEUE,
115 .this_id = ATA_SHT_THIS_ID,
116 .sg_tablesize = LIBATA_MAX_PRD,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
118 .emulated = ATA_SHT_EMULATED,
119 .use_clustering = ATA_SHT_USE_CLUSTERING,
120 .proc_name = DRV_NAME,
121 .dma_boundary = ATA_DMA_BOUNDARY,
122 .slave_configure = ata_scsi_slave_config,
Tejun Heoccf68c32006-05-31 18:28:09 +0900123 .slave_destroy = ata_scsi_slave_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 .bios_param = ata_std_bios_param,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125};
126
Jeff Garzik057ace52005-10-22 14:27:05 -0400127static const struct ata_port_operations pdc_sata_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 .port_disable = ata_port_disable,
129 .tf_load = pdc_tf_load_mmio,
130 .tf_read = ata_tf_read,
131 .check_status = ata_check_status,
132 .exec_command = pdc_exec_command_mmio,
133 .dev_select = ata_std_dev_select,
Jeff Garzik2cba5822005-08-29 05:12:30 -0400134
135 .phy_reset = pdc_sata_phy_reset,
136
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 .qc_prep = pdc_qc_prep,
138 .qc_issue = pdc_qc_issue_prot,
139 .eng_timeout = pdc_eng_timeout,
Alan Coxa6b2c5d2006-05-22 16:59:59 +0100140 .data_xfer = ata_mmio_data_xfer,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 .irq_handler = pdc_interrupt,
142 .irq_clear = pdc_irq_clear,
Jeff Garzik2cba5822005-08-29 05:12:30 -0400143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 .scr_read = pdc_sata_scr_read,
145 .scr_write = pdc_sata_scr_write,
146 .port_start = pdc_port_start,
147 .port_stop = pdc_port_stop,
Luke Kosewski6340f012006-01-28 12:39:29 -0500148 .host_stop = pdc_host_stop,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149};
150
Jeff Garzik057ace52005-10-22 14:27:05 -0400151static const struct ata_port_operations pdc_pata_ops = {
Jeff Garzik2cba5822005-08-29 05:12:30 -0400152 .port_disable = ata_port_disable,
153 .tf_load = pdc_tf_load_mmio,
154 .tf_read = ata_tf_read,
155 .check_status = ata_check_status,
156 .exec_command = pdc_exec_command_mmio,
157 .dev_select = ata_std_dev_select,
158
159 .phy_reset = pdc_pata_phy_reset,
160
161 .qc_prep = pdc_qc_prep,
162 .qc_issue = pdc_qc_issue_prot,
Alan Coxa6b2c5d2006-05-22 16:59:59 +0100163 .data_xfer = ata_mmio_data_xfer,
Jeff Garzik2cba5822005-08-29 05:12:30 -0400164 .eng_timeout = pdc_eng_timeout,
165 .irq_handler = pdc_interrupt,
166 .irq_clear = pdc_irq_clear,
167
168 .port_start = pdc_port_start,
169 .port_stop = pdc_port_stop,
Luke Kosewski6340f012006-01-28 12:39:29 -0500170 .host_stop = pdc_host_stop,
Jeff Garzik2cba5822005-08-29 05:12:30 -0400171};
172
Arjan van de Ven98ac62d2005-11-28 10:06:23 +0100173static const struct ata_port_info pdc_port_info[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 /* board_2037x */
175 {
176 .sht = &pdc_ata_sht,
Jeff Garzikcca39742006-08-24 03:19:22 -0400177 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 .pio_mask = 0x1f, /* pio0-4 */
179 .mwdma_mask = 0x07, /* mwdma0-2 */
180 .udma_mask = 0x7f, /* udma0-6 ; FIXME */
Jeff Garzik2cba5822005-08-29 05:12:30 -0400181 .port_ops = &pdc_sata_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 },
183
184 /* board_20319 */
185 {
186 .sht = &pdc_ata_sht,
Jeff Garzikcca39742006-08-24 03:19:22 -0400187 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 .pio_mask = 0x1f, /* pio0-4 */
189 .mwdma_mask = 0x07, /* mwdma0-2 */
190 .udma_mask = 0x7f, /* udma0-6 ; FIXME */
Jeff Garzik2cba5822005-08-29 05:12:30 -0400191 .port_ops = &pdc_sata_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 },
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400193
194 /* board_20619 */
195 {
196 .sht = &pdc_ata_sht,
Jeff Garzikcca39742006-08-24 03:19:22 -0400197 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SLAVE_POSS,
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400198 .pio_mask = 0x1f, /* pio0-4 */
199 .mwdma_mask = 0x07, /* mwdma0-2 */
200 .udma_mask = 0x7f, /* udma0-6 ; FIXME */
Jeff Garzik2cba5822005-08-29 05:12:30 -0400201 .port_ops = &pdc_pata_ops,
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400202 },
Yusuf Iskenderoglu5a46fe82006-01-17 08:06:21 -0500203
204 /* board_20771 */
205 {
206 .sht = &pdc_ata_sht,
Jeff Garzikcca39742006-08-24 03:19:22 -0400207 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA,
Yusuf Iskenderoglu5a46fe82006-01-17 08:06:21 -0500208 .pio_mask = 0x1f, /* pio0-4 */
209 .mwdma_mask = 0x07, /* mwdma0-2 */
210 .udma_mask = 0x7f, /* udma0-6 ; FIXME */
211 .port_ops = &pdc_sata_ops,
212 },
Luke Kosewski6340f012006-01-28 12:39:29 -0500213
214 /* board_2057x */
215 {
216 .sht = &pdc_ata_sht,
Jeff Garzikcca39742006-08-24 03:19:22 -0400217 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA,
Luke Kosewski6340f012006-01-28 12:39:29 -0500218 .pio_mask = 0x1f, /* pio0-4 */
219 .mwdma_mask = 0x07, /* mwdma0-2 */
220 .udma_mask = 0x7f, /* udma0-6 ; FIXME */
221 .port_ops = &pdc_sata_ops,
222 },
223
224 /* board_40518 */
225 {
226 .sht = &pdc_ata_sht,
Jeff Garzikcca39742006-08-24 03:19:22 -0400227 .flags = PDC_COMMON_FLAGS | ATA_FLAG_SATA,
Luke Kosewski6340f012006-01-28 12:39:29 -0500228 .pio_mask = 0x1f, /* pio0-4 */
229 .mwdma_mask = 0x07, /* mwdma0-2 */
230 .udma_mask = 0x7f, /* udma0-6 ; FIXME */
231 .port_ops = &pdc_sata_ops,
232 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233};
234
Jeff Garzik3b7d6972005-11-10 11:04:11 -0500235static const struct pci_device_id pdc_ata_pci_tbl[] = {
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400236 { PCI_VDEVICE(PROMISE, 0x3371), board_2037x },
237 { PCI_VDEVICE(PROMISE, 0x3570), board_2037x },
238 { PCI_VDEVICE(PROMISE, 0x3571), board_2037x },
239 { PCI_VDEVICE(PROMISE, 0x3373), board_2037x },
240 { PCI_VDEVICE(PROMISE, 0x3375), board_2037x },
241 { PCI_VDEVICE(PROMISE, 0x3376), board_2037x },
242 { PCI_VDEVICE(PROMISE, 0x3574), board_2057x },
243 { PCI_VDEVICE(PROMISE, 0x3d75), board_2057x },
244 { PCI_VDEVICE(PROMISE, 0x3d73), board_2037x },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400246 { PCI_VDEVICE(PROMISE, 0x3318), board_20319 },
247 { PCI_VDEVICE(PROMISE, 0x3319), board_20319 },
248 { PCI_VDEVICE(PROMISE, 0x3515), board_20319 },
249 { PCI_VDEVICE(PROMISE, 0x3519), board_20319 },
250 { PCI_VDEVICE(PROMISE, 0x3d17), board_20319 },
251 { PCI_VDEVICE(PROMISE, 0x3d18), board_40518 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400253 { PCI_VDEVICE(PROMISE, 0x6629), board_20619 },
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400254
Jeff Garzik8419dc82006-07-24 03:37:52 -0400255/* TODO: remove all associated board_20771 code, as it completely
256 * duplicates board_2037x code, unless reason for separation can be
257 * divined.
258 */
259#if 0
Jeff Garzik54bb3a942006-09-27 22:20:11 -0400260 { PCI_VDEVICE(PROMISE, 0x3570), board_20771 },
Jeff Garzik8419dc82006-07-24 03:37:52 -0400261#endif
Jeff Garzika83068b2006-10-11 04:46:52 -0400262 { PCI_VDEVICE(PROMISE, 0x3577), board_20771 },
Jeff Garzik8419dc82006-07-24 03:37:52 -0400263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 { } /* terminate list */
265};
266
267
268static struct pci_driver pdc_ata_pci_driver = {
269 .name = DRV_NAME,
270 .id_table = pdc_ata_pci_tbl,
271 .probe = pdc_ata_init_one,
272 .remove = ata_pci_remove_one,
273};
274
275
276static int pdc_port_start(struct ata_port *ap)
277{
Jeff Garzikcca39742006-08-24 03:19:22 -0400278 struct device *dev = ap->host->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 struct pdc_port_priv *pp;
280 int rc;
281
282 rc = ata_port_start(ap);
283 if (rc)
284 return rc;
285
Luke Kosewski6340f012006-01-28 12:39:29 -0500286 pp = kzalloc(sizeof(*pp), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 if (!pp) {
288 rc = -ENOMEM;
289 goto err_out;
290 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 pp->pkt = dma_alloc_coherent(dev, 128, &pp->pkt_dma, GFP_KERNEL);
293 if (!pp->pkt) {
294 rc = -ENOMEM;
295 goto err_out_kfree;
296 }
297
298 ap->private_data = pp;
299
300 return 0;
301
302err_out_kfree:
303 kfree(pp);
304err_out:
305 ata_port_stop(ap);
306 return rc;
307}
308
309
310static void pdc_port_stop(struct ata_port *ap)
311{
Jeff Garzikcca39742006-08-24 03:19:22 -0400312 struct device *dev = ap->host->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 struct pdc_port_priv *pp = ap->private_data;
314
315 ap->private_data = NULL;
316 dma_free_coherent(dev, 128, pp->pkt, pp->pkt_dma);
317 kfree(pp);
318 ata_port_stop(ap);
319}
320
321
Jeff Garzikcca39742006-08-24 03:19:22 -0400322static void pdc_host_stop(struct ata_host *host)
Luke Kosewski6340f012006-01-28 12:39:29 -0500323{
Jeff Garzikcca39742006-08-24 03:19:22 -0400324 struct pdc_host_priv *hp = host->private_data;
Luke Kosewski6340f012006-01-28 12:39:29 -0500325
Jeff Garzikcca39742006-08-24 03:19:22 -0400326 ata_pci_host_stop(host);
Luke Kosewski6340f012006-01-28 12:39:29 -0500327
328 kfree(hp);
329}
330
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332static void pdc_reset_port(struct ata_port *ap)
333{
Jeff Garzikea6ba102005-08-30 05:18:18 -0400334 void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_CTLSTAT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 unsigned int i;
336 u32 tmp;
337
338 for (i = 11; i > 0; i--) {
339 tmp = readl(mmio);
340 if (tmp & PDC_RESET)
341 break;
342
343 udelay(100);
344
345 tmp |= PDC_RESET;
346 writel(tmp, mmio);
347 }
348
349 tmp &= ~PDC_RESET;
350 writel(tmp, mmio);
351 readl(mmio); /* flush */
352}
353
Jeff Garzik2cba5822005-08-29 05:12:30 -0400354static void pdc_sata_phy_reset(struct ata_port *ap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
356 pdc_reset_port(ap);
357 sata_phy_reset(ap);
358}
359
Jeff Garzikd3fb4e82006-05-24 01:43:25 -0400360static void pdc_pata_cbl_detect(struct ata_port *ap)
361{
362 u8 tmp;
Al Viro03dc5502006-10-10 22:48:07 +0100363 void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_CTLSTAT + 0x03;
Jeff Garzikd3fb4e82006-05-24 01:43:25 -0400364
365 tmp = readb(mmio);
366
367 if (tmp & 0x01) {
368 ap->cbl = ATA_CBL_PATA40;
369 ap->udma_mask &= ATA_UDMA_MASK_40C;
370 } else
371 ap->cbl = ATA_CBL_PATA80;
372}
373
Jeff Garzik2cba5822005-08-29 05:12:30 -0400374static void pdc_pata_phy_reset(struct ata_port *ap)
375{
Jeff Garzikd3fb4e82006-05-24 01:43:25 -0400376 pdc_pata_cbl_detect(ap);
Jeff Garzik2cba5822005-08-29 05:12:30 -0400377 pdc_reset_port(ap);
378 ata_port_probe(ap);
379 ata_bus_reset(ap);
380}
381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
383{
384 if (sc_reg > SCR_CONTROL)
385 return 0xffffffffU;
Al Virob181d3b2005-10-21 06:46:02 +0100386 return readl((void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387}
388
389
390static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
391 u32 val)
392{
393 if (sc_reg > SCR_CONTROL)
394 return;
Al Virob181d3b2005-10-21 06:46:02 +0100395 writel(val, (void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397
398static void pdc_qc_prep(struct ata_queued_cmd *qc)
399{
400 struct pdc_port_priv *pp = qc->ap->private_data;
401 unsigned int i;
402
403 VPRINTK("ENTER\n");
404
405 switch (qc->tf.protocol) {
406 case ATA_PROT_DMA:
407 ata_qc_prep(qc);
408 /* fall through */
409
410 case ATA_PROT_NODATA:
411 i = pdc_pkt_header(&qc->tf, qc->ap->prd_dma,
412 qc->dev->devno, pp->pkt);
413
414 if (qc->tf.flags & ATA_TFLAG_LBA48)
415 i = pdc_prep_lba48(&qc->tf, pp->pkt, i);
416 else
417 i = pdc_prep_lba28(&qc->tf, pp->pkt, i);
418
419 pdc_pkt_footer(&qc->tf, pp->pkt, i);
420 break;
421
422 default:
423 break;
424 }
425}
426
427static void pdc_eng_timeout(struct ata_port *ap)
428{
Jeff Garzikcca39742006-08-24 03:19:22 -0400429 struct ata_host *host = ap->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 u8 drv_stat;
431 struct ata_queued_cmd *qc;
Jeff Garzikb8f61532005-08-25 22:01:20 -0400432 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 DPRINTK("ENTER\n");
435
Jeff Garzikcca39742006-08-24 03:19:22 -0400436 spin_lock_irqsave(&host->lock, flags);
Jeff Garzikb8f61532005-08-25 22:01:20 -0400437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 qc = ata_qc_from_tag(ap, ap->active_tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 switch (qc->tf.protocol) {
441 case ATA_PROT_DMA:
442 case ATA_PROT_NODATA:
Tejun Heof15a1da2006-05-15 20:57:56 +0900443 ata_port_printk(ap, KERN_ERR, "command timeout\n");
Jeff Garzika7dac442005-10-30 04:44:42 -0500444 drv_stat = ata_wait_idle(ap);
Albert Leea22e2eb2005-12-05 15:38:02 +0800445 qc->err_mask |= __ac_err_mask(drv_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 break;
447
448 default:
449 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
450
Tejun Heof15a1da2006-05-15 20:57:56 +0900451 ata_port_printk(ap, KERN_ERR,
452 "unknown timeout, cmd 0x%x stat 0x%x\n",
453 qc->tf.command, drv_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Albert Leea22e2eb2005-12-05 15:38:02 +0800455 qc->err_mask |= ac_err_mask(drv_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 break;
457 }
458
Jeff Garzikcca39742006-08-24 03:19:22 -0400459 spin_unlock_irqrestore(&host->lock, flags);
Tejun Heof6379022006-02-10 15:10:48 +0900460 ata_eh_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 DPRINTK("EXIT\n");
462}
463
464static inline unsigned int pdc_host_intr( struct ata_port *ap,
465 struct ata_queued_cmd *qc)
466{
Albert Leea22e2eb2005-12-05 15:38:02 +0800467 unsigned int handled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 u32 tmp;
Jeff Garzikea6ba102005-08-30 05:18:18 -0400469 void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_GLOBAL_CTL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471 tmp = readl(mmio);
472 if (tmp & PDC_ERR_MASK) {
Albert Leea22e2eb2005-12-05 15:38:02 +0800473 qc->err_mask |= AC_ERR_DEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 pdc_reset_port(ap);
475 }
476
477 switch (qc->tf.protocol) {
478 case ATA_PROT_DMA:
479 case ATA_PROT_NODATA:
Albert Leea22e2eb2005-12-05 15:38:02 +0800480 qc->err_mask |= ac_err_mask(ata_wait_idle(ap));
481 ata_qc_complete(qc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 handled = 1;
483 break;
484
485 default:
Albert Leeee500aa2005-09-27 17:34:38 +0800486 ap->stats.idle_irq++;
487 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 }
489
Albert Leeee500aa2005-09-27 17:34:38 +0800490 return handled;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491}
492
493static void pdc_irq_clear(struct ata_port *ap)
494{
Jeff Garzikcca39742006-08-24 03:19:22 -0400495 struct ata_host *host = ap->host;
496 void __iomem *mmio = host->mmio_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498 readl(mmio + PDC_INT_SEQMASK);
499}
500
David Howells7d12e782006-10-05 14:55:46 +0100501static irqreturn_t pdc_interrupt (int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Jeff Garzikcca39742006-08-24 03:19:22 -0400503 struct ata_host *host = dev_instance;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 struct ata_port *ap;
505 u32 mask = 0;
506 unsigned int i, tmp;
507 unsigned int handled = 0;
Jeff Garzikea6ba102005-08-30 05:18:18 -0400508 void __iomem *mmio_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
510 VPRINTK("ENTER\n");
511
Jeff Garzikcca39742006-08-24 03:19:22 -0400512 if (!host || !host->mmio_base) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 VPRINTK("QUICK EXIT\n");
514 return IRQ_NONE;
515 }
516
Jeff Garzikcca39742006-08-24 03:19:22 -0400517 mmio_base = host->mmio_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519 /* reading should also clear interrupts */
520 mask = readl(mmio_base + PDC_INT_SEQMASK);
521
522 if (mask == 0xffffffff) {
523 VPRINTK("QUICK EXIT 2\n");
524 return IRQ_NONE;
525 }
Luke Kosewski6340f012006-01-28 12:39:29 -0500526
Jeff Garzikcca39742006-08-24 03:19:22 -0400527 spin_lock(&host->lock);
Luke Kosewski6340f012006-01-28 12:39:29 -0500528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 mask &= 0xffff; /* only 16 tags possible */
530 if (!mask) {
531 VPRINTK("QUICK EXIT 3\n");
Luke Kosewski6340f012006-01-28 12:39:29 -0500532 goto done_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 }
534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 writel(mask, mmio_base + PDC_INT_SEQMASK);
536
Jeff Garzikcca39742006-08-24 03:19:22 -0400537 for (i = 0; i < host->n_ports; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 VPRINTK("port %u\n", i);
Jeff Garzikcca39742006-08-24 03:19:22 -0400539 ap = host->ports[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 tmp = mask & (1 << (i + 1));
Tejun Heoc1389502005-08-22 14:59:24 +0900541 if (tmp && ap &&
Jeff Garzik029f5462006-04-02 10:30:40 -0400542 !(ap->flags & ATA_FLAG_DISABLED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 struct ata_queued_cmd *qc;
544
545 qc = ata_qc_from_tag(ap, ap->active_tag);
Albert Leee50362e2005-09-27 17:39:50 +0800546 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 handled += pdc_host_intr(ap, qc);
548 }
549 }
550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 VPRINTK("EXIT\n");
552
Luke Kosewski6340f012006-01-28 12:39:29 -0500553done_irq:
Jeff Garzikcca39742006-08-24 03:19:22 -0400554 spin_unlock(&host->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 return IRQ_RETVAL(handled);
556}
557
558static inline void pdc_packet_start(struct ata_queued_cmd *qc)
559{
560 struct ata_port *ap = qc->ap;
561 struct pdc_port_priv *pp = ap->private_data;
562 unsigned int port_no = ap->port_no;
563 u8 seq = (u8) (port_no + 1);
564
565 VPRINTK("ENTER, ap %p\n", ap);
566
Jeff Garzikcca39742006-08-24 03:19:22 -0400567 writel(0x00000001, ap->host->mmio_base + (seq * 4));
568 readl(ap->host->mmio_base + (seq * 4)); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 pp->pkt[2] = seq;
571 wmb(); /* flush PRD, pkt writes */
Al Virob181d3b2005-10-21 06:46:02 +0100572 writel(pp->pkt_dma, (void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
573 readl((void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574}
575
Tejun Heo9a3d9eb2006-01-23 13:09:36 +0900576static unsigned int pdc_qc_issue_prot(struct ata_queued_cmd *qc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577{
578 switch (qc->tf.protocol) {
579 case ATA_PROT_DMA:
580 case ATA_PROT_NODATA:
581 pdc_packet_start(qc);
582 return 0;
583
584 case ATA_PROT_ATAPI_DMA:
585 BUG();
586 break;
587
588 default:
589 break;
590 }
591
592 return ata_qc_issue_prot(qc);
593}
594
Jeff Garzik057ace52005-10-22 14:27:05 -0400595static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
597 WARN_ON (tf->protocol == ATA_PROT_DMA ||
598 tf->protocol == ATA_PROT_NODATA);
599 ata_tf_load(ap, tf);
600}
601
602
Jeff Garzik057ace52005-10-22 14:27:05 -0400603static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
605 WARN_ON (tf->protocol == ATA_PROT_DMA ||
606 tf->protocol == ATA_PROT_NODATA);
607 ata_exec_command(ap, tf);
608}
609
610
611static void pdc_ata_setup_port(struct ata_ioports *port, unsigned long base)
612{
613 port->cmd_addr = base;
614 port->data_addr = base;
615 port->feature_addr =
616 port->error_addr = base + 0x4;
617 port->nsect_addr = base + 0x8;
618 port->lbal_addr = base + 0xc;
619 port->lbam_addr = base + 0x10;
620 port->lbah_addr = base + 0x14;
621 port->device_addr = base + 0x18;
622 port->command_addr =
623 port->status_addr = base + 0x1c;
624 port->altstatus_addr =
625 port->ctl_addr = base + 0x38;
626}
627
628
629static void pdc_host_init(unsigned int chip_id, struct ata_probe_ent *pe)
630{
Jeff Garzikea6ba102005-08-30 05:18:18 -0400631 void __iomem *mmio = pe->mmio_base;
Luke Kosewski6340f012006-01-28 12:39:29 -0500632 struct pdc_host_priv *hp = pe->private_data;
633 int hotplug_offset = hp->hotplug_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 u32 tmp;
635
636 /*
637 * Except for the hotplug stuff, this is voodoo from the
638 * Promise driver. Label this entire section
639 * "TODO: figure out why we do this"
640 */
641
642 /* change FIFO_SHD to 8 dwords, enable BMR_BURST */
643 tmp = readl(mmio + PDC_FLASH_CTL);
644 tmp |= 0x12000; /* bit 16 (fifo 8 dw) and 13 (bmr burst?) */
645 writel(tmp, mmio + PDC_FLASH_CTL);
646
647 /* clear plug/unplug flags for all ports */
Luke Kosewski6340f012006-01-28 12:39:29 -0500648 tmp = readl(mmio + hotplug_offset);
649 writel(tmp | 0xff, mmio + hotplug_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651 /* mask plug/unplug ints */
Luke Kosewski6340f012006-01-28 12:39:29 -0500652 tmp = readl(mmio + hotplug_offset);
653 writel(tmp | 0xff0000, mmio + hotplug_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655 /* reduce TBG clock to 133 Mhz. */
656 tmp = readl(mmio + PDC_TBG_MODE);
657 tmp &= ~0x30000; /* clear bit 17, 16*/
658 tmp |= 0x10000; /* set bit 17:16 = 0:1 */
659 writel(tmp, mmio + PDC_TBG_MODE);
660
661 readl(mmio + PDC_TBG_MODE); /* flush */
662 msleep(10);
663
664 /* adjust slew rate control register. */
665 tmp = readl(mmio + PDC_SLEW_CTL);
666 tmp &= 0xFFFFF03F; /* clear bit 11 ~ 6 */
667 tmp |= 0x00000900; /* set bit 11-9 = 100b , bit 8-6 = 100 */
668 writel(tmp, mmio + PDC_SLEW_CTL);
669}
670
671static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
672{
673 static int printed_version;
674 struct ata_probe_ent *probe_ent = NULL;
Luke Kosewski6340f012006-01-28 12:39:29 -0500675 struct pdc_host_priv *hp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 unsigned long base;
Jeff Garzikea6ba102005-08-30 05:18:18 -0400677 void __iomem *mmio_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 unsigned int board_idx = (unsigned int) ent->driver_data;
679 int pci_dev_busy = 0;
680 int rc;
681
682 if (!printed_version++)
Jeff Garzika9524a72005-10-30 14:39:11 -0500683 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 rc = pci_enable_device(pdev);
686 if (rc)
687 return rc;
688
689 rc = pci_request_regions(pdev, DRV_NAME);
690 if (rc) {
691 pci_dev_busy = 1;
692 goto err_out;
693 }
694
695 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
696 if (rc)
697 goto err_out_regions;
698 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
699 if (rc)
700 goto err_out_regions;
701
Luke Kosewski6340f012006-01-28 12:39:29 -0500702 probe_ent = kzalloc(sizeof(*probe_ent), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 if (probe_ent == NULL) {
704 rc = -ENOMEM;
705 goto err_out_regions;
706 }
707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 probe_ent->dev = pci_dev_to_dev(pdev);
709 INIT_LIST_HEAD(&probe_ent->node);
710
Jeff Garzik374b1872005-08-30 05:42:52 -0400711 mmio_base = pci_iomap(pdev, 3, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 if (mmio_base == NULL) {
713 rc = -ENOMEM;
714 goto err_out_free_ent;
715 }
716 base = (unsigned long) mmio_base;
717
Luke Kosewski6340f012006-01-28 12:39:29 -0500718 hp = kzalloc(sizeof(*hp), GFP_KERNEL);
719 if (hp == NULL) {
720 rc = -ENOMEM;
721 goto err_out_free_ent;
722 }
723
724 /* Set default hotplug offset */
725 hp->hotplug_offset = PDC_SATA_PLUG_CSR;
726 probe_ent->private_data = hp;
727
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 probe_ent->sht = pdc_port_info[board_idx].sht;
Jeff Garzikcca39742006-08-24 03:19:22 -0400729 probe_ent->port_flags = pdc_port_info[board_idx].flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 probe_ent->pio_mask = pdc_port_info[board_idx].pio_mask;
731 probe_ent->mwdma_mask = pdc_port_info[board_idx].mwdma_mask;
732 probe_ent->udma_mask = pdc_port_info[board_idx].udma_mask;
733 probe_ent->port_ops = pdc_port_info[board_idx].port_ops;
734
735 probe_ent->irq = pdev->irq;
Thomas Gleixner1d6f3592006-07-01 19:29:42 -0700736 probe_ent->irq_flags = IRQF_SHARED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 probe_ent->mmio_base = mmio_base;
738
739 pdc_ata_setup_port(&probe_ent->port[0], base + 0x200);
740 pdc_ata_setup_port(&probe_ent->port[1], base + 0x280);
741
742 probe_ent->port[0].scr_addr = base + 0x400;
743 probe_ent->port[1].scr_addr = base + 0x500;
744
745 /* notice 4-port boards */
746 switch (board_idx) {
Luke Kosewski6340f012006-01-28 12:39:29 -0500747 case board_40518:
748 /* Override hotplug offset for SATAII150 */
749 hp->hotplug_offset = PDC2_SATA_PLUG_CSR;
750 /* Fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 case board_20319:
752 probe_ent->n_ports = 4;
753
754 pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
755 pdc_ata_setup_port(&probe_ent->port[3], base + 0x380);
756
757 probe_ent->port[2].scr_addr = base + 0x600;
758 probe_ent->port[3].scr_addr = base + 0x700;
759 break;
Luke Kosewski6340f012006-01-28 12:39:29 -0500760 case board_2057x:
761 /* Override hotplug offset for SATAII150 */
762 hp->hotplug_offset = PDC2_SATA_PLUG_CSR;
763 /* Fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 case board_2037x:
Jeff Garzik6c9e5eb2005-11-30 16:42:55 -0500765 probe_ent->n_ports = 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 break;
Yusuf Iskenderoglu5a46fe82006-01-17 08:06:21 -0500767 case board_20771:
768 probe_ent->n_ports = 2;
769 break;
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400770 case board_20619:
771 probe_ent->n_ports = 4;
772
773 pdc_ata_setup_port(&probe_ent->port[2], base + 0x300);
774 pdc_ata_setup_port(&probe_ent->port[3], base + 0x380);
775
776 probe_ent->port[2].scr_addr = base + 0x600;
777 probe_ent->port[3].scr_addr = base + 0x700;
Jeff Garzik6c9e5eb2005-11-30 16:42:55 -0500778 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 default:
780 BUG();
781 break;
782 }
783
784 pci_set_master(pdev);
785
786 /* initialize adapter */
787 pdc_host_init(board_idx, probe_ent);
788
Luke Kosewski6340f012006-01-28 12:39:29 -0500789 /* FIXME: Need any other frees than hp? */
790 if (!ata_device_add(probe_ent))
791 kfree(hp);
792
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 kfree(probe_ent);
794
795 return 0;
796
797err_out_free_ent:
798 kfree(probe_ent);
799err_out_regions:
800 pci_release_regions(pdev);
801err_out:
802 if (!pci_dev_busy)
803 pci_disable_device(pdev);
804 return rc;
805}
806
807
808static int __init pdc_ata_init(void)
809{
Pavel Roskinb7887192006-08-10 18:13:18 +0900810 return pci_register_driver(&pdc_ata_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
812
813
814static void __exit pdc_ata_exit(void)
815{
816 pci_unregister_driver(&pdc_ata_pci_driver);
817}
818
819
820MODULE_AUTHOR("Jeff Garzik");
Tobias Lorenzf497ba72005-05-12 15:51:01 -0400821MODULE_DESCRIPTION("Promise ATA TX2/TX4/TX4000 low-level driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822MODULE_LICENSE("GPL");
823MODULE_DEVICE_TABLE(pci, pdc_ata_pci_tbl);
824MODULE_VERSION(DRV_VERSION);
825
826module_init(pdc_ata_init);
827module_exit(pdc_ata_exit);