sata_sil24.c 38.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * sata_sil24.c - Driver for Silicon Image 3124/3132 SATA-2 controllers
 *
 * Copyright 2005  Tejun Heo
 *
 * Based on preview driver from Silicon Image.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
27
#include <linux/device.h>
28
#include <scsi/scsi_host.h>
29
#include <scsi/scsi_cmnd.h>
30 31 32
#include <linux/libata.h>

#define DRV_NAME	"sata_sil24"
33
#define DRV_VERSION	"1.1"
34 35 36 37 38

/*
 * Port request block (PRB) 32 bytes
 */
struct sil24_prb {
39 40 41
	__le16	ctrl;
	__le16	prot;
	__le32	rx_cnt;
42 43 44 45 46 47 48
	u8	fis[6 * 4];
};

/*
 * Scatter gather entry (SGE) 16 bytes
 */
struct sil24_sge {
49 50 51
	__le64	addr;
	__le32	cnt;
	__le32	flags;
52 53 54 55 56 57
};

/*
 * Port multiplier
 */
struct sil24_port_multiplier {
58 59
	__le32	diag;
	__le32	sactive;
60 61 62
};

enum {
Tejun Heo's avatar
Tejun Heo committed
63 64 65
	SIL24_HOST_BAR		= 0,
	SIL24_PORT_BAR		= 2,

Tejun Heo's avatar
Tejun Heo committed
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
	/* sil24 fetches in chunks of 64bytes.  The first block
	 * contains the PRB and two SGEs.  From the second block, it's
	 * consisted of four SGEs and called SGT.  Calculate the
	 * number of SGTs that fit into one page.
	 */
	SIL24_PRB_SZ		= sizeof(struct sil24_prb)
				  + 2 * sizeof(struct sil24_sge),
	SIL24_MAX_SGT		= (PAGE_SIZE - SIL24_PRB_SZ)
				  / (4 * sizeof(struct sil24_sge)),

	/* This will give us one unused SGEs for ATA.  This extra SGE
	 * will be used to store CDB for ATAPI devices.
	 */
	SIL24_MAX_SGE		= 4 * SIL24_MAX_SGT + 1,

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
	/*
	 * Global controller registers (128 bytes @ BAR0)
	 */
		/* 32 bit regs */
	HOST_SLOT_STAT		= 0x00, /* 32 bit slot stat * 4 */
	HOST_CTRL		= 0x40,
	HOST_IRQ_STAT		= 0x44,
	HOST_PHY_CFG		= 0x48,
	HOST_BIST_CTRL		= 0x50,
	HOST_BIST_PTRN		= 0x54,
	HOST_BIST_STAT		= 0x58,
	HOST_MEM_BIST_STAT	= 0x5c,
	HOST_FLASH_CMD		= 0x70,
		/* 8 bit regs */
	HOST_FLASH_DATA		= 0x74,
	HOST_TRANSITION_DETECT	= 0x75,
	HOST_GPIO_CTRL		= 0x76,
	HOST_I2C_ADDR		= 0x78, /* 32 bit */
	HOST_I2C_DATA		= 0x7c,
	HOST_I2C_XFER_CNT	= 0x7e,
	HOST_I2C_CTRL		= 0x7f,

	/* HOST_SLOT_STAT bits */
	HOST_SSTAT_ATTN		= (1 << 31),

106 107 108 109 110 111
	/* HOST_CTRL bits */
	HOST_CTRL_M66EN		= (1 << 16), /* M66EN PCI bus signal */
	HOST_CTRL_TRDY		= (1 << 17), /* latched PCI TRDY */
	HOST_CTRL_STOP		= (1 << 18), /* latched PCI STOP */
	HOST_CTRL_DEVSEL	= (1 << 19), /* latched PCI DEVSEL */
	HOST_CTRL_REQ64		= (1 << 20), /* latched PCI REQ64 */
112
	HOST_CTRL_GLOBAL_RST	= (1 << 31), /* global reset */
113

114 115 116 117 118
	/*
	 * Port registers
	 * (8192 bytes @ +0x0000, +0x2000, +0x4000 and +0x6000 @ BAR2)
	 */
	PORT_REGS_SIZE		= 0x2000,
119

120
	PORT_LRAM		= 0x0000, /* 31 LRAM slots and PMP regs */
121
	PORT_LRAM_SLOT_SZ	= 0x0080, /* 32 bytes PRB + 2 SGE, ACT... */
122

123
	PORT_PMP		= 0x0f80, /* 8 bytes PMP * 16 (128 bytes) */
124 125 126 127
	PORT_PMP_STATUS		= 0x0000, /* port device status offset */
	PORT_PMP_QACTIVE	= 0x0004, /* port device QActive offset */
	PORT_PMP_SIZE		= 0x0008, /* 8 bytes per PMP */

128
		/* 32 bit regs */
129 130 131 132 133
	PORT_CTRL_STAT		= 0x1000, /* write: ctrl-set, read: stat */
	PORT_CTRL_CLR		= 0x1004, /* write: ctrl-clear */
	PORT_IRQ_STAT		= 0x1008, /* high: status, low: interrupt */
	PORT_IRQ_ENABLE_SET	= 0x1010, /* write: enable-set */
	PORT_IRQ_ENABLE_CLR	= 0x1014, /* write: enable-clear */
134
	PORT_ACTIVATE_UPPER_ADDR= 0x101c,
135 136
	PORT_EXEC_FIFO		= 0x1020, /* command execution fifo */
	PORT_CMD_ERR		= 0x1024, /* command error number */
137 138 139 140 141 142 143 144 145 146 147 148 149
	PORT_FIS_CFG		= 0x1028,
	PORT_FIFO_THRES		= 0x102c,
		/* 16 bit regs */
	PORT_DECODE_ERR_CNT	= 0x1040,
	PORT_DECODE_ERR_THRESH	= 0x1042,
	PORT_CRC_ERR_CNT	= 0x1044,
	PORT_CRC_ERR_THRESH	= 0x1046,
	PORT_HSHK_ERR_CNT	= 0x1048,
	PORT_HSHK_ERR_THRESH	= 0x104a,
		/* 32 bit regs */
	PORT_PHY_CFG		= 0x1050,
	PORT_SLOT_STAT		= 0x1800,
	PORT_CMD_ACTIVATE	= 0x1c00, /* 64 bit cmd activate * 31 (248 bytes) */
150
	PORT_CONTEXT		= 0x1e04,
151 152 153 154 155 156 157 158 159 160 161 162
	PORT_EXEC_DIAG		= 0x1e00, /* 32bit exec diag * 16 (64 bytes, 0-10 used on 3124) */
	PORT_PSD_DIAG		= 0x1e40, /* 32bit psd diag * 16 (64 bytes, 0-8 used on 3124) */
	PORT_SCONTROL		= 0x1f00,
	PORT_SSTATUS		= 0x1f04,
	PORT_SERROR		= 0x1f08,
	PORT_SACTIVE		= 0x1f0c,

	/* PORT_CTRL_STAT bits */
	PORT_CS_PORT_RST	= (1 << 0), /* port reset */
	PORT_CS_DEV_RST		= (1 << 1), /* device reset */
	PORT_CS_INIT		= (1 << 2), /* port initialize */
	PORT_CS_IRQ_WOC		= (1 << 3), /* interrupt write one to clear */
Tejun Heo's avatar
Tejun Heo committed
163
	PORT_CS_CDB16		= (1 << 5), /* 0=12b cdb, 1=16b cdb */
164
	PORT_CS_PMP_RESUME	= (1 << 6), /* PMP resume */
165
	PORT_CS_32BIT_ACTV	= (1 << 10), /* 32-bit activation */
166
	PORT_CS_PMP_EN		= (1 << 13), /* port multiplier enable */
167
	PORT_CS_RDY		= (1 << 31), /* port ready to accept commands */
168 169 170 171 172 173 174 175 176

	/* PORT_IRQ_STAT/ENABLE_SET/CLR */
	/* bits[11:0] are masked */
	PORT_IRQ_COMPLETE	= (1 << 0), /* command(s) completed */
	PORT_IRQ_ERROR		= (1 << 1), /* command execution error */
	PORT_IRQ_PORTRDY_CHG	= (1 << 2), /* port ready change */
	PORT_IRQ_PWR_CHG	= (1 << 3), /* power management change */
	PORT_IRQ_PHYRDY_CHG	= (1 << 4), /* PHY ready change */
	PORT_IRQ_COMWAKE	= (1 << 5), /* COMWAKE received */
177 178 179 180 181
	PORT_IRQ_UNK_FIS	= (1 << 6), /* unknown FIS received */
	PORT_IRQ_DEV_XCHG	= (1 << 7), /* device exchanged */
	PORT_IRQ_8B10B		= (1 << 8), /* 8b/10b decode error threshold */
	PORT_IRQ_CRC		= (1 << 9), /* CRC error threshold */
	PORT_IRQ_HANDSHAKE	= (1 << 10), /* handshake error threshold */
182
	PORT_IRQ_SDB_NOTIFY	= (1 << 11), /* SDB notify received */
183

184
	DEF_PORT_IRQ		= PORT_IRQ_COMPLETE | PORT_IRQ_ERROR |
185
				  PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG |
Tejun Heo's avatar
Tejun Heo committed
186
				  PORT_IRQ_UNK_FIS | PORT_IRQ_SDB_NOTIFY,
187

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
	/* bits[27:16] are unmasked (raw) */
	PORT_IRQ_RAW_SHIFT	= 16,
	PORT_IRQ_MASKED_MASK	= 0x7ff,
	PORT_IRQ_RAW_MASK	= (0x7ff << PORT_IRQ_RAW_SHIFT),

	/* ENABLE_SET/CLR specific, intr steering - 2 bit field */
	PORT_IRQ_STEER_SHIFT	= 30,
	PORT_IRQ_STEER_MASK	= (3 << PORT_IRQ_STEER_SHIFT),

	/* PORT_CMD_ERR constants */
	PORT_CERR_DEV		= 1, /* Error bit in D2H Register FIS */
	PORT_CERR_SDB		= 2, /* Error bit in SDB FIS */
	PORT_CERR_DATA		= 3, /* Error in data FIS not detected by dev */
	PORT_CERR_SEND		= 4, /* Initial cmd FIS transmission failure */
	PORT_CERR_INCONSISTENT	= 5, /* Protocol mismatch */
	PORT_CERR_DIRECTION	= 6, /* Data direction mismatch */
	PORT_CERR_UNDERRUN	= 7, /* Ran out of SGEs while writing */
	PORT_CERR_OVERRUN	= 8, /* Ran out of SGEs while reading */
	PORT_CERR_PKT_PROT	= 11, /* DIR invalid in 1st PIO setup of ATAPI */
	PORT_CERR_SGT_BOUNDARY	= 16, /* PLD ecode 00 - SGT not on qword boundary */
	PORT_CERR_SGT_TGTABRT	= 17, /* PLD ecode 01 - target abort */
	PORT_CERR_SGT_MSTABRT	= 18, /* PLD ecode 10 - master abort */
	PORT_CERR_SGT_PCIPERR	= 19, /* PLD ecode 11 - PCI parity err while fetching SGT */
	PORT_CERR_CMD_BOUNDARY	= 24, /* ctrl[15:13] 001 - PRB not on qword boundary */
	PORT_CERR_CMD_TGTABRT	= 25, /* ctrl[15:13] 010 - target abort */
	PORT_CERR_CMD_MSTABRT	= 26, /* ctrl[15:13] 100 - master abort */
	PORT_CERR_CMD_PCIPERR	= 27, /* ctrl[15:13] 110 - PCI parity err while fetching PRB */
	PORT_CERR_XFR_UNDEF	= 32, /* PSD ecode 00 - undefined */
	PORT_CERR_XFR_TGTABRT	= 33, /* PSD ecode 01 - target abort */
Tejun Heo's avatar
Tejun Heo committed
217
	PORT_CERR_XFR_MSTABRT	= 34, /* PSD ecode 10 - master abort */
218
	PORT_CERR_XFR_PCIPERR	= 35, /* PSD ecode 11 - PCI prity err during transfer */
219
	PORT_CERR_SENDSERVICE	= 36, /* FIS received while sending service */
220

Tejun Heo's avatar
Tejun Heo committed
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
	/* bits of PRB control field */
	PRB_CTRL_PROTOCOL	= (1 << 0), /* override def. ATA protocol */
	PRB_CTRL_PACKET_READ	= (1 << 4), /* PACKET cmd read */
	PRB_CTRL_PACKET_WRITE	= (1 << 5), /* PACKET cmd write */
	PRB_CTRL_NIEN		= (1 << 6), /* Mask completion irq */
	PRB_CTRL_SRST		= (1 << 7), /* Soft reset request (ign BSY?) */

	/* PRB protocol field */
	PRB_PROT_PACKET		= (1 << 0),
	PRB_PROT_TCQ		= (1 << 1),
	PRB_PROT_NCQ		= (1 << 2),
	PRB_PROT_READ		= (1 << 3),
	PRB_PROT_WRITE		= (1 << 4),
	PRB_PROT_TRANSPARENT	= (1 << 5),

236 237 238 239
	/*
	 * Other constants
	 */
	SGE_TRM			= (1 << 31), /* Last SGE in chain */
Tejun Heo's avatar
Tejun Heo committed
240 241 242 243
	SGE_LNK			= (1 << 30), /* linked list
						Points to SGT, not SGE */
	SGE_DRD			= (1 << 29), /* discard data read (/dev/null)
						data address ignored */
244

245 246
	SIL24_MAX_CMDS		= 31,

247 248 249
	/* board id */
	BID_SIL3124		= 0,
	BID_SIL3132		= 1,
250
	BID_SIL3131		= 2,
251

252 253
	/* host flags */
	SIL24_COMMON_FLAGS	= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
254
				  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
Tejun Heo's avatar
Tejun Heo committed
255
				  ATA_FLAG_NCQ | ATA_FLAG_ACPI_SATA |
256
				  ATA_FLAG_AN | ATA_FLAG_PMP,
257
	SIL24_FLAG_PCIX_IRQ_WOC	= (1 << 24), /* IRQ loss errata on PCI-X */
258

259 260 261
	IRQ_STAT_4PORTS		= 0xf,
};

Tejun Heo's avatar
Tejun Heo committed
262
struct sil24_ata_block {
263
	struct sil24_prb prb;
Tejun Heo's avatar
Tejun Heo committed
264
	struct sil24_sge sge[SIL24_MAX_SGE];
265 266
};

Tejun Heo's avatar
Tejun Heo committed
267 268 269
struct sil24_atapi_block {
	struct sil24_prb prb;
	u8 cdb[16];
Tejun Heo's avatar
Tejun Heo committed
270
	struct sil24_sge sge[SIL24_MAX_SGE];
Tejun Heo's avatar
Tejun Heo committed
271 272 273 274 275 276 277
};

union sil24_cmd_block {
	struct sil24_ata_block ata;
	struct sil24_atapi_block atapi;
};

278 279 280 281
static struct sil24_cerr_info {
	unsigned int err_mask, action;
	const char *desc;
} sil24_cerr_db[] = {
282
	[0]			= { AC_ERR_DEV, 0,
283
				    "device error" },
284
	[PORT_CERR_DEV]		= { AC_ERR_DEV, 0,
285
				    "device error via D2H FIS" },
286
	[PORT_CERR_SDB]		= { AC_ERR_DEV, 0,
287
				    "device error via SDB FIS" },
Tejun Heo's avatar
Tejun Heo committed
288
	[PORT_CERR_DATA]	= { AC_ERR_ATA_BUS, ATA_EH_RESET,
289
				    "error in data FIS" },
Tejun Heo's avatar
Tejun Heo committed
290
	[PORT_CERR_SEND]	= { AC_ERR_ATA_BUS, ATA_EH_RESET,
291
				    "failed to transmit command FIS" },
Tejun Heo's avatar
Tejun Heo committed
292
	[PORT_CERR_INCONSISTENT] = { AC_ERR_HSM, ATA_EH_RESET,
293
				     "protocol mismatch" },
Tejun Heo's avatar
Tejun Heo committed
294
	[PORT_CERR_DIRECTION]	= { AC_ERR_HSM, ATA_EH_RESET,
295
				    "data directon mismatch" },
Tejun Heo's avatar
Tejun Heo committed
296
	[PORT_CERR_UNDERRUN]	= { AC_ERR_HSM, ATA_EH_RESET,
297
				    "ran out of SGEs while writing" },
Tejun Heo's avatar
Tejun Heo committed
298
	[PORT_CERR_OVERRUN]	= { AC_ERR_HSM, ATA_EH_RESET,
299
				    "ran out of SGEs while reading" },
Tejun Heo's avatar
Tejun Heo committed
300
	[PORT_CERR_PKT_PROT]	= { AC_ERR_HSM, ATA_EH_RESET,
301
				    "invalid data directon for ATAPI CDB" },
Tejun Heo's avatar
Tejun Heo committed
302
	[PORT_CERR_SGT_BOUNDARY] = { AC_ERR_SYSTEM, ATA_EH_RESET,
Tejun Heo's avatar
Tejun Heo committed
303
				     "SGT not on qword boundary" },
Tejun Heo's avatar
Tejun Heo committed
304
	[PORT_CERR_SGT_TGTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
305
				    "PCI target abort while fetching SGT" },
Tejun Heo's avatar
Tejun Heo committed
306
	[PORT_CERR_SGT_MSTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
307
				    "PCI master abort while fetching SGT" },
Tejun Heo's avatar
Tejun Heo committed
308
	[PORT_CERR_SGT_PCIPERR]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
309
				    "PCI parity error while fetching SGT" },
Tejun Heo's avatar
Tejun Heo committed
310
	[PORT_CERR_CMD_BOUNDARY] = { AC_ERR_SYSTEM, ATA_EH_RESET,
311
				     "PRB not on qword boundary" },
Tejun Heo's avatar
Tejun Heo committed
312
	[PORT_CERR_CMD_TGTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
313
				    "PCI target abort while fetching PRB" },
Tejun Heo's avatar
Tejun Heo committed
314
	[PORT_CERR_CMD_MSTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
315
				    "PCI master abort while fetching PRB" },
Tejun Heo's avatar
Tejun Heo committed
316
	[PORT_CERR_CMD_PCIPERR]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
317
				    "PCI parity error while fetching PRB" },
Tejun Heo's avatar
Tejun Heo committed
318
	[PORT_CERR_XFR_UNDEF]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
319
				    "undefined error while transferring data" },
Tejun Heo's avatar
Tejun Heo committed
320
	[PORT_CERR_XFR_TGTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
321
				    "PCI target abort while transferring data" },
Tejun Heo's avatar
Tejun Heo committed
322
	[PORT_CERR_XFR_MSTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
323
				    "PCI master abort while transferring data" },
Tejun Heo's avatar
Tejun Heo committed
324
	[PORT_CERR_XFR_PCIPERR]	= { AC_ERR_HOST_BUS, ATA_EH_RESET,
325
				    "PCI parity error while transferring data" },
Tejun Heo's avatar
Tejun Heo committed
326
	[PORT_CERR_SENDSERVICE]	= { AC_ERR_HSM, ATA_EH_RESET,
327 328 329
				    "FIS received while sending service FIS" },
};

330 331 332 333 334 335 336
/*
 * ap->private_data
 *
 * The preview driver always returned 0 for status.  We emulate it
 * here from the previous interrupt.
 */
struct sil24_port_priv {
Tejun Heo's avatar
Tejun Heo committed
337
	union sil24_cmd_block *cmd_block;	/* 32 cmd blocks */
338
	dma_addr_t cmd_block_dma;		/* DMA base addr for them */
339
	struct ata_taskfile tf;			/* Cached taskfile registers */
Tejun Heo's avatar
Tejun Heo committed
340
	int do_port_rst;
341 342
};

343
static void sil24_dev_config(struct ata_device *dev);
344
static u8 sil24_check_status(struct ata_port *ap);
345 346
static int sil24_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val);
static int sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
347
static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
348
static int sil24_qc_defer(struct ata_queued_cmd *qc);
349
static void sil24_qc_prep(struct ata_queued_cmd *qc);
350
static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
351
static bool sil24_qc_fill_rtf(struct ata_queued_cmd *qc);
352 353
static void sil24_pmp_attach(struct ata_port *ap);
static void sil24_pmp_detach(struct ata_port *ap);
354 355
static void sil24_freeze(struct ata_port *ap);
static void sil24_thaw(struct ata_port *ap);
356 357 358 359 360 361 362 363
static int sil24_softreset(struct ata_link *link, unsigned int *class,
			   unsigned long deadline);
static int sil24_hardreset(struct ata_link *link, unsigned int *class,
			   unsigned long deadline);
static int sil24_pmp_softreset(struct ata_link *link, unsigned int *class,
			       unsigned long deadline);
static int sil24_pmp_hardreset(struct ata_link *link, unsigned int *class,
			       unsigned long deadline);
364 365
static void sil24_error_handler(struct ata_port *ap);
static void sil24_post_internal_cmd(struct ata_queued_cmd *qc);
366 367
static int sil24_port_start(struct ata_port *ap);
static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
368
#ifdef CONFIG_PM
369
static int sil24_pci_device_resume(struct pci_dev *pdev);
370
static int sil24_port_resume(struct ata_port *ap);
371
#endif
372

373
static const struct pci_device_id sil24_pci_tbl[] = {
374 375 376
	{ PCI_VDEVICE(CMD, 0x3124), BID_SIL3124 },
	{ PCI_VDEVICE(INTEL, 0x3124), BID_SIL3124 },
	{ PCI_VDEVICE(CMD, 0x3132), BID_SIL3132 },
377
	{ PCI_VDEVICE(CMD, 0x0242), BID_SIL3132 },
378 379 380
	{ PCI_VDEVICE(CMD, 0x3131), BID_SIL3131 },
	{ PCI_VDEVICE(CMD, 0x3531), BID_SIL3131 },

Tejun Heo's avatar
Tejun Heo committed
381
	{ } /* terminate list */
382 383 384 385 386 387
};

static struct pci_driver sil24_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= sil24_pci_tbl,
	.probe			= sil24_init_one,
388
	.remove			= ata_pci_remove_one,
389
#ifdef CONFIG_PM
390 391
	.suspend		= ata_pci_device_suspend,
	.resume			= sil24_pci_device_resume,
392
#endif
393 394
};

395
static struct scsi_host_template sil24_sht = {
396
	ATA_NCQ_SHT(DRV_NAME),
397
	.can_queue		= SIL24_MAX_CMDS,
Tejun Heo's avatar
Tejun Heo committed
398
	.sg_tablesize		= SIL24_MAX_SGE,
399 400 401
	.dma_boundary		= ATA_DMA_BOUNDARY,
};

402 403
static struct ata_port_operations sil24_ops = {
	.inherits		= &sata_pmp_port_ops,
Tejun Heo's avatar
Tejun Heo committed
404

Tejun Heo's avatar
Tejun Heo committed
405 406 407
	.sff_check_status	= sil24_check_status,
	.sff_check_altstatus	= sil24_check_status,
	.sff_tf_read		= sil24_tf_read,
408
	.qc_defer		= sil24_qc_defer,
409 410
	.qc_prep		= sil24_qc_prep,
	.qc_issue		= sil24_qc_issue,
411
	.qc_fill_rtf		= sil24_qc_fill_rtf,
412

413 414
	.freeze			= sil24_freeze,
	.thaw			= sil24_thaw,
415 416 417 418
	.softreset		= sil24_softreset,
	.hardreset		= sil24_hardreset,
	.pmp_softreset		= sil24_pmp_softreset,
	.pmp_hardreset		= sil24_pmp_hardreset,
419 420 421
	.error_handler		= sil24_error_handler,
	.post_internal_cmd	= sil24_post_internal_cmd,
	.dev_config		= sil24_dev_config,
422 423 424

	.scr_read		= sil24_scr_read,
	.scr_write		= sil24_scr_write,
425 426 427
	.pmp_attach		= sil24_pmp_attach,
	.pmp_detach		= sil24_pmp_detach,

428
	.port_start		= sil24_port_start,
429 430 431
#ifdef CONFIG_PM
	.port_resume		= sil24_port_resume,
#endif
432 433
};

434
/*
Jeff Garzik's avatar
Jeff Garzik committed
435
 * Use bits 30-31 of port_flags to encode available port numbers.
436 437 438 439 440
 * Current maxium is 4.
 */
#define SIL24_NPORTS2FLAG(nports)	((((unsigned)(nports) - 1) & 0x3) << 30)
#define SIL24_FLAG2NPORTS(flag)		((((flag) >> 30) & 0x3) + 1)

441
static const struct ata_port_info sil24_port_info[] = {
442 443
	/* sil_3124 */
	{
Jeff Garzik's avatar
Jeff Garzik committed
444
		.flags		= SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(4) |
445
				  SIL24_FLAG_PCIX_IRQ_WOC,
446 447
		.pio_mask	= 0x1f,			/* pio0-4 */
		.mwdma_mask	= 0x07,			/* mwdma0-2 */
448
		.udma_mask	= ATA_UDMA5,		/* udma0-5 */
449 450
		.port_ops	= &sil24_ops,
	},
451
	/* sil_3132 */
452
	{
Jeff Garzik's avatar
Jeff Garzik committed
453
		.flags		= SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(2),
454 455
		.pio_mask	= 0x1f,			/* pio0-4 */
		.mwdma_mask	= 0x07,			/* mwdma0-2 */
456
		.udma_mask	= ATA_UDMA5,		/* udma0-5 */
457 458 459 460
		.port_ops	= &sil24_ops,
	},
	/* sil_3131/sil_3531 */
	{
Jeff Garzik's avatar
Jeff Garzik committed
461
		.flags		= SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(1),
462 463
		.pio_mask	= 0x1f,			/* pio0-4 */
		.mwdma_mask	= 0x07,			/* mwdma0-2 */
464
		.udma_mask	= ATA_UDMA5,		/* udma0-5 */
465 466 467 468
		.port_ops	= &sil24_ops,
	},
};

469 470 471 472 473 474 475
static int sil24_tag(int tag)
{
	if (unlikely(ata_tag_internal(tag)))
		return 0;
	return tag;
}

476
static void sil24_dev_config(struct ata_device *dev)
Tejun Heo's avatar
Tejun Heo committed
477
{
Tejun Heo's avatar
Tejun Heo committed
478
	void __iomem *port = dev->link->ap->ioaddr.cmd_addr;
Tejun Heo's avatar
Tejun Heo committed
479

480
	if (dev->cdb_len == 16)
Tejun Heo's avatar
Tejun Heo committed
481 482 483 484 485
		writel(PORT_CS_CDB16, port + PORT_CTRL_STAT);
	else
		writel(PORT_CS_CDB16, port + PORT_CTRL_CLR);
}

486
static void sil24_read_tf(struct ata_port *ap, int tag, struct ata_taskfile *tf)
487
{
Tejun Heo's avatar
Tejun Heo committed
488
	void __iomem *port = ap->ioaddr.cmd_addr;
489
	struct sil24_prb __iomem *prb;
490
	u8 fis[6 * 4];
491

492 493 494
	prb = port + PORT_LRAM + sil24_tag(tag) * PORT_LRAM_SLOT_SZ;
	memcpy_fromio(fis, prb->fis, sizeof(fis));
	ata_tf_from_fis(fis, tf);
495 496
}

497 498
static u8 sil24_check_status(struct ata_port *ap)
{
499 500
	struct sil24_port_priv *pp = ap->private_data;
	return pp->tf.command;
501 502 503 504 505 506 507 508 509
}

static int sil24_scr_map[] = {
	[SCR_CONTROL]	= 0,
	[SCR_STATUS]	= 1,
	[SCR_ERROR]	= 2,
	[SCR_ACTIVE]	= 3,
};

510
static int sil24_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val)
511
{
Tejun Heo's avatar
Tejun Heo committed
512
	void __iomem *scr_addr = ap->ioaddr.scr_addr;
513

514
	if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
515
		void __iomem *addr;
516
		addr = scr_addr + sil24_scr_map[sc_reg] * 4;
517 518
		*val = readl(scr_addr + sil24_scr_map[sc_reg] * 4);
		return 0;
519
	}
520
	return -EINVAL;
521 522
}

523
static int sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
524
{
Tejun Heo's avatar
Tejun Heo committed
525
	void __iomem *scr_addr = ap->ioaddr.scr_addr;
526

527
	if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
528
		void __iomem *addr;
529 530
		addr = scr_addr + sil24_scr_map[sc_reg] * 4;
		writel(val, scr_addr + sil24_scr_map[sc_reg] * 4);
531
		return 0;
532
	}
533
	return -EINVAL;
534 535
}

536 537 538 539 540 541
static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
{
	struct sil24_port_priv *pp = ap->private_data;
	*tf = pp->tf;
}

Tejun Heo's avatar
Tejun Heo committed
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
static void sil24_config_port(struct ata_port *ap)
{
	void __iomem *port = ap->ioaddr.cmd_addr;

	/* configure IRQ WoC */
	if (ap->flags & SIL24_FLAG_PCIX_IRQ_WOC)
		writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_STAT);
	else
		writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);

	/* zero error counters. */
	writel(0x8000, port + PORT_DECODE_ERR_THRESH);
	writel(0x8000, port + PORT_CRC_ERR_THRESH);
	writel(0x8000, port + PORT_HSHK_ERR_THRESH);
	writel(0x0000, port + PORT_DECODE_ERR_CNT);
	writel(0x0000, port + PORT_CRC_ERR_CNT);
	writel(0x0000, port + PORT_HSHK_ERR_CNT);

	/* always use 64bit activation */
	writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_CLR);

	/* clear port multiplier enable and resume bits */
	writel(PORT_CS_PMP_EN | PORT_CS_PMP_RESUME, port + PORT_CTRL_CLR);
}

567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
static void sil24_config_pmp(struct ata_port *ap, int attached)
{
	void __iomem *port = ap->ioaddr.cmd_addr;

	if (attached)
		writel(PORT_CS_PMP_EN, port + PORT_CTRL_STAT);
	else
		writel(PORT_CS_PMP_EN, port + PORT_CTRL_CLR);
}

static void sil24_clear_pmp(struct ata_port *ap)
{
	void __iomem *port = ap->ioaddr.cmd_addr;
	int i;

	writel(PORT_CS_PMP_RESUME, port + PORT_CTRL_CLR);

	for (i = 0; i < SATA_PMP_MAX_PORTS; i++) {
		void __iomem *pmp_base = port + PORT_PMP + i * PORT_PMP_SIZE;

		writel(0, pmp_base + PORT_PMP_STATUS);
		writel(0, pmp_base + PORT_PMP_QACTIVE);
	}
}

592 593
static int sil24_init_port(struct ata_port *ap)
{
Tejun Heo's avatar
Tejun Heo committed
594
	void __iomem *port = ap->ioaddr.cmd_addr;
Tejun Heo's avatar
Tejun Heo committed
595
	struct sil24_port_priv *pp = ap->private_data;
596 597
	u32 tmp;

598 599 600 601
	/* clear PMP error status */
	if (ap->nr_pmp_links)
		sil24_clear_pmp(ap);

602 603 604 605 606 607
	writel(PORT_CS_INIT, port + PORT_CTRL_STAT);
	ata_wait_register(port + PORT_CTRL_STAT,
			  PORT_CS_INIT, PORT_CS_INIT, 10, 100);
	tmp = ata_wait_register(port + PORT_CTRL_STAT,
				PORT_CS_RDY, 0, 10, 100);

Tejun Heo's avatar
Tejun Heo committed
608 609
	if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY) {
		pp->do_port_rst = 1;
Tejun Heo's avatar
Tejun Heo committed
610
		ap->link.eh_context.i.action |= ATA_EH_RESET;
611
		return -EIO;
Tejun Heo's avatar
Tejun Heo committed
612 613
	}

614 615 616
	return 0;
}

617 618 619 620
static int sil24_exec_polled_cmd(struct ata_port *ap, int pmp,
				 const struct ata_taskfile *tf,
				 int is_cmd, u32 ctrl,
				 unsigned long timeout_msec)
621
{
Tejun Heo's avatar
Tejun Heo committed
622
	void __iomem *port = ap->ioaddr.cmd_addr;
623
	struct sil24_port_priv *pp = ap->private_data;
Tejun Heo's avatar
Tejun Heo committed
624
	struct sil24_prb *prb = &pp->cmd_block[0].ata.prb;
625
	dma_addr_t paddr = pp->cmd_block_dma;
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
	u32 irq_enabled, irq_mask, irq_stat;
	int rc;

	prb->ctrl = cpu_to_le16(ctrl);
	ata_tf_to_fis(tf, pmp, is_cmd, prb->fis);

	/* temporarily plug completion and error interrupts */
	irq_enabled = readl(port + PORT_IRQ_ENABLE_SET);
	writel(PORT_IRQ_COMPLETE | PORT_IRQ_ERROR, port + PORT_IRQ_ENABLE_CLR);

	writel((u32)paddr, port + PORT_CMD_ACTIVATE);
	writel((u64)paddr >> 32, port + PORT_CMD_ACTIVATE + 4);

	irq_mask = (PORT_IRQ_COMPLETE | PORT_IRQ_ERROR) << PORT_IRQ_RAW_SHIFT;
	irq_stat = ata_wait_register(port + PORT_IRQ_STAT, irq_mask, 0x0,
				     10, timeout_msec);

	writel(irq_mask, port + PORT_IRQ_STAT); /* clear IRQs */
	irq_stat >>= PORT_IRQ_RAW_SHIFT;

	if (irq_stat & PORT_IRQ_COMPLETE)
		rc = 0;
	else {
		/* force port into known state */
		sil24_init_port(ap);

		if (irq_stat & PORT_IRQ_ERROR)
			rc = -EIO;
		else
			rc = -EBUSY;
	}

	/* restore IRQ enabled */
	writel(irq_enabled, port + PORT_IRQ_ENABLE_SET);

	return rc;
}

Tejun Heo's avatar
Tejun Heo committed
664
static int sil24_do_softreset(struct ata_link *link, unsigned int *class,
665
			      int pmp, unsigned long deadline)
666
{
Tejun Heo's avatar
Tejun Heo committed
667
	struct ata_port *ap = link->ap;
668
	unsigned long timeout_msec = 0;
669
	struct ata_taskfile tf;
670
	const char *reason;
671
	int rc;
672

673 674
	DPRINTK("ENTER\n");

Tejun Heo's avatar
Tejun Heo committed
675
	if (ata_link_offline(link)) {
676 677 678 679 680
		DPRINTK("PHY reports no device\n");
		*class = ATA_DEV_NONE;
		goto out;
	}

681 682
	/* put the port into known state */
	if (sil24_init_port(ap)) {
683
		reason = "port not ready";
684 685 686
		goto err;
	}

687
	/* do SRST */
688 689
	if (time_after(deadline, jiffies))
		timeout_msec = jiffies_to_msecs(deadline - jiffies);
690

Tejun Heo's avatar
Tejun Heo committed
691
	ata_tf_init(link->device, &tf);	/* doesn't really matter */
692 693
	rc = sil24_exec_polled_cmd(ap, pmp, &tf, 0, PRB_CTRL_SRST,
				   timeout_msec);
694 695 696 697 698
	if (rc == -EBUSY) {
		reason = "timeout";
		goto err;
	} else if (rc) {
		reason = "SRST command error";
699
		goto err;
700
	}
701

702 703
	sil24_read_tf(ap, 0, &tf);
	*class = ata_dev_classify(&tf);
704

705 706
	if (*class == ATA_DEV_UNKNOWN)
		*class = ATA_DEV_NONE;
707

708
 out:
709
	DPRINTK("EXIT, class=%u\n", *class);
710
	return 0;
711 712

 err:
Tejun Heo's avatar
Tejun Heo committed
713
	ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
714
	return -EIO;
715 716
}

Tejun Heo's avatar
Tejun Heo committed
717
static int sil24_softreset(struct ata_link *link, unsigned int *class,
718 719
			   unsigned long deadline)
{
720
	return sil24_do_softreset(link, class, SATA_PMP_CTRL_PORT, deadline);
721 722
}

Tejun Heo's avatar
Tejun Heo committed
723
static int sil24_hardreset(struct ata_link *link, unsigned int *class,
724
			   unsigned long deadline)
725
{
Tejun Heo's avatar
Tejun Heo committed
726
	struct ata_port *ap = link->ap;
Tejun Heo's avatar
Tejun Heo committed
727
	void __iomem *port = ap->ioaddr.cmd_addr;
Tejun Heo's avatar
Tejun Heo committed
728 729
	struct sil24_port_priv *pp = ap->private_data;
	int did_port_rst = 0;
730
	const char *reason;
731
	int tout_msec, rc;
732 733
	u32 tmp;

Tejun Heo's avatar
Tejun Heo committed
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
 retry:
	/* Sometimes, DEV_RST is not enough to recover the controller.
	 * This happens often after PM DMA CS errata.
	 */
	if (pp->do_port_rst) {
		ata_port_printk(ap, KERN_WARNING, "controller in dubious "
				"state, performing PORT_RST\n");

		writel(PORT_CS_PORT_RST, port + PORT_CTRL_STAT);
		msleep(10);
		writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
		ata_wait_register(port + PORT_CTRL_STAT, PORT_CS_RDY, 0,
				  10, 5000);

		/* restore port configuration */
		sil24_config_port(ap);
		sil24_config_pmp(ap, ap->nr_pmp_links);

		pp->do_port_rst = 0;
		did_port_rst = 1;
	}

756
	/* sil24 does the right thing(tm) without any protection */
Tejun Heo's avatar
Tejun Heo committed
757
	sata_set_spd(link);
758 759

	tout_msec = 100;
Tejun Heo's avatar
Tejun Heo committed
760
	if (ata_link_online(link))
761 762 763 764
		tout_msec = 5000;

	writel(PORT_CS_DEV_RST, port + PORT_CTRL_STAT);
	tmp = ata_wait_register(port + PORT_CTRL_STAT,
765 766
				PORT_CS_DEV_RST, PORT_CS_DEV_RST, 10,
				tout_msec);
767

768 769
	/* SStatus oscillates between zero and valid status after
	 * DEV_RST, debounce it.
770
	 */
Tejun Heo's avatar
Tejun Heo committed
771
	rc = sata_link_debounce(link, sata_deb_timing_long, deadline);
772 773 774 775
	if (rc) {
		reason = "PHY debouncing failed";
		goto err;
	}
776 777

	if (tmp & PORT_CS_DEV_RST) {
Tejun Heo's avatar
Tejun Heo committed
778
		if (ata_link_offline(link))
779 780 781 782 783
			return 0;
		reason = "link not ready";
		goto err;
	}

784 785 786 787 788
	/* Sil24 doesn't store signature FIS after hardreset, so we
	 * can't wait for BSY to clear.  Some devices take a long time
	 * to get ready and those devices will choke if we don't wait
	 * for BSY clearance here.  Tell libata to perform follow-up
	 * softreset.
789
	 */
790
	return -EAGAIN;
791 792

 err:
Tejun Heo's avatar
Tejun Heo committed
793 794 795 796 797
	if (!did_port_rst) {
		pp->do_port_rst = 1;
		goto retry;
	}

Tejun Heo's avatar
Tejun Heo committed
798
	ata_link_printk(link, KERN_ERR, "hardreset failed (%s)\n", reason);
799
	return -EIO;
800 801
}

802
static inline void sil24_fill_sg(struct ata_queued_cmd *qc,
Tejun Heo's avatar
Tejun Heo committed
803
				 struct sil24_sge *sge)
804
{
805
	struct scatterlist *sg;
Jeff Garzik's avatar
Jeff Garzik committed
806
	struct sil24_sge *last_sge = NULL;
Tejun Heo's avatar
Tejun Heo committed
807
	unsigned int si;
808

Tejun Heo's avatar
Tejun Heo committed
809
	for_each_sg(qc->sg, sg, qc->n_elem, si) {
810 811
		sge->addr = cpu_to_le64(sg_dma_address(sg));
		sge->cnt = cpu_to_le32(sg_dma_len(sg));
Jeff Garzik's avatar
Jeff Garzik committed
812 813 814
		sge->flags = 0;

		last_sge = sge;
815
		sge++;
816
	}
Jeff Garzik's avatar
Jeff Garzik committed
817

Tejun Heo's avatar
Tejun Heo committed
818
	last_sge->flags = cpu_to_le32(SGE_TRM);
819 820
}

821 822 823 824 825
static int sil24_qc_defer(struct ata_queued_cmd *qc)
{
	struct ata_link *link = qc->dev->link;
	struct ata_port *ap = link->ap;
	u8 prot = qc->tf.protocol;
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845

	/*
	 * There is a bug in the chip:
	 * Port LRAM Causes the PRB/SGT Data to be Corrupted
	 * If the host issues a read request for LRAM and SActive registers
	 * while active commands are available in the port, PRB/SGT data in
	 * the LRAM can become corrupted. This issue applies only when
	 * reading from, but not writing to, the LRAM.
	 *
	 * Therefore, reading LRAM when there is no particular error [and
	 * other commands may be outstanding] is prohibited.
	 *
	 * To avoid this bug there are two situations where a command must run
	 * exclusive of any other commands on the port:
	 *
	 * - ATAPI commands which check the sense data
	 * - Passthrough ATA commands which always have ATA_QCFLAG_RESULT_TF
	 *   set.
	 *
 	 */
Tejun Heo's avatar
Tejun Heo committed
846
	int is_excl = (ata_is_atapi(prot) ||
847 848
		       (qc->flags & ATA_QCFLAG_RESULT_TF));

849 850 851 852 853 854 855
	if (unlikely(ap->excl_link)) {
		if (link == ap->excl_link) {
			if (ap->nr_active_links)
				return ATA_DEFER_PORT;
			qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
		} else
			return ATA_DEFER_PORT;
856
	} else if (unlikely(is_excl)) {
857 858 859 860 861 862 863 864 865
		ap->excl_link = link;
		if (ap->nr_active_links)
			return ATA_DEFER_PORT;
		qc->flags |= ATA_QCFLAG_CLEAR_EXCL;
	}

	return ata_std_qc_defer(qc);
}

866 867 868 869
static void sil24_qc_prep(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	struct sil24_port_priv *pp = ap->private_data;
870
	union sil24_cmd_block *cb;
Tejun Heo's avatar
Tejun Heo committed
871 872
	struct sil24_prb *prb;
	struct sil24_sge *sge;
873
	u16 ctrl = 0;
874

875 876
	cb = &pp->cmd_block[sil24_tag(qc->tag)];

Tejun Heo's avatar
Tejun Heo committed
877
	if (!ata_is_atapi(qc->tf.protocol)) {
Tejun Heo's avatar
Tejun Heo committed
878 879
		prb = &cb->ata.prb;
		sge = cb->ata.sge;
Tejun Heo's avatar
Tejun Heo committed
880
	} else {
Tejun Heo's avatar
Tejun Heo committed
881 882 883
		prb = &cb->atapi.prb;
		sge = cb->atapi.sge;
		memset(cb->atapi.cdb, 0, 32);
884
		memcpy(cb->atapi.cdb, qc->cdb, qc->dev->cdb_len);
Tejun Heo's avatar
Tejun Heo committed
885

Tejun Heo's avatar
Tejun Heo committed
886
		if (ata_is_data(qc->tf.protocol)) {
Tejun Heo's avatar
Tejun Heo committed
887
			if (qc->tf.flags & ATA_TFLAG_WRITE)
888
				ctrl = PRB_CTRL_PACKET_WRITE;
Tejun Heo's avatar
Tejun Heo committed
889
			else
890 891
				ctrl = PRB_CTRL_PACKET_READ;
		}
892 893
	}

894
	prb->ctrl = cpu_to_le16(ctrl);
895
	ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, prb->fis);
896 897

	if (qc->flags & ATA_QCFLAG_DMAMAP)
Tejun Heo's avatar
Tejun Heo committed
898
		sil24_fill_sg(qc, sge);
899 900
}

901
static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc)
902 903 904
{
	struct ata_port *ap = qc->ap;
	struct sil24_port_priv *pp = ap->private_data;
Tejun Heo's avatar
Tejun Heo committed
905
	void __iomem *port = ap->ioaddr.cmd_addr;
906 907 908
	unsigned int tag = sil24_tag(qc->tag);
	dma_addr_t paddr;
	void __iomem *activate;
909

910 911 912 913 914
	paddr = pp->cmd_block_dma + tag * sizeof(*pp->cmd_block);
	activate = port + PORT_CMD_ACTIVATE + tag * 8;

	writel((u32)paddr, activate);
	writel((u64)paddr >> 32, activate + 4);
Tejun Heo's avatar
Tejun Heo committed
915

916 917 918
	return 0;
}

919 920 921 922 923 924
static bool sil24_qc_fill_rtf(struct ata_queued_cmd *qc)
{
	sil24_read_tf(qc->ap, qc->tag, &qc->result_tf);
	return true;
}

925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
static void sil24_pmp_attach(struct ata_port *ap)
{
	sil24_config_pmp(ap, 1);
	sil24_init_port(ap);
}

static void sil24_pmp_detach(struct ata_port *ap)
{
	sil24_init_port(ap);
	sil24_config_pmp(ap, 0);
}

static int sil24_pmp_softreset(struct ata_link *link, unsigned int *class,
			       unsigned long deadline)
{
	return sil24_do_softreset(link, class, link->pmp, deadline);
}

static int sil24_pmp_hardreset(struct ata_link *link, unsigned int *class,
			       unsigned long deadline)
{
	int rc;

	rc = sil24_init_port(link->ap);
	if (rc) {
		ata_link_printk(link, KERN_ERR,
				"hardreset failed (port not ready)\n");
		return rc;
	}

955
	return sata_std_hardreset(link, class, deadline);
956 957
}

958
static void sil24_freeze(struct ata_port *ap)
959
{
Tejun Heo's avatar
Tejun Heo committed
960
	void __iomem *port = ap->ioaddr.cmd_addr;
961

962 963 964 965
	/* Port-wide IRQ mask in HOST_CTRL doesn't really work, clear
	 * PORT_IRQ_ENABLE instead.
	 */
	writel(0xffff, port + PORT_IRQ_ENABLE_CLR);
966 967
}

968
static void sil24_thaw(struct ata_port *ap)
969
{
Tejun Heo's avatar
Tejun Heo committed
970
	void __iomem *port = ap->ioaddr.cmd_addr;
971 972
	u32 tmp;

973 974 975
	/* clear IRQ */
	tmp = readl(port + PORT_IRQ_STAT);
	writel(tmp, port + PORT_IRQ_STAT);
976

977 978
	/* turn IRQ back on */
	writel(DEF_PORT_IRQ, port + PORT_IRQ_ENABLE_SET);
979 980
}

981
static void sil24_error_intr(struct ata_port *ap)
982
{
Tejun Heo's avatar
Tejun Heo committed
983
	void __iomem *port = ap->ioaddr.cmd_addr;
984
	struct sil24_port_priv *pp = ap->private_data;
985 986 987 988
	struct ata_queued_cmd *qc = NULL;
	struct ata_link *link;
	struct ata_eh_info *ehi;
	int abort = 0, freeze = 0;
989
	u32 irq_stat;
990

991
	/* on error, we need to clear IRQ explicitly */
992
	irq_stat = readl(port + PORT_IRQ_STAT);
993
	writel(irq_stat, port + PORT_IRQ_STAT);
994

995
	/* first, analyze and record host port events */
996 997
	link = &ap->link;
	ehi = &link->eh_info;
998
	ata_ehi_clear_desc(ehi);
999

1000
	ata_ehi_push_desc(ehi, "irq_stat 0x%08x", irq_stat);
1001

Tejun Heo's avatar
Tejun Heo committed
1002 1003
	if (irq_stat & PORT_IRQ_SDB_NOTIFY) {
		ata_ehi_push_desc(ehi, "SDB notify");
1004
		sata_async_notification(ap);
Tejun Heo's avatar
Tejun Heo committed
1005 1006
	}

1007 1008
	if (irq_stat & (PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG)) {
		ata_ehi_hotplugged(ehi);
1009 1010 1011
		ata_ehi_push_desc(ehi, "%s",
				  irq_stat & PORT_IRQ_PHYRDY_CHG ?
				  "PHY RDY changed" : "device exchanged");
1012
		freeze = 1;
1013 1014
	}

1015 1016
	if (irq_stat & PORT_IRQ_UNK_FIS) {
		ehi->err_mask |= AC_ERR_HSM;
Tejun Heo's avatar
Tejun Heo committed
1017
		ehi->action |= ATA_EH_RESET;
1018
		ata_ehi_push_desc(ehi, "unknown FIS");
1019 1020 1021 1022 1023 1024 1025
		freeze = 1;
	}

	/* deal with command error */
	if (irq_stat & PORT_IRQ_ERROR) {
		struct sil24_cerr_info *ci = NULL;
		unsigned int err_mask = 0, action = 0;
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
		u32 context, cerr;
		int pmp;

		abort = 1;

		/* DMA Context Switch Failure in Port Multiplier Mode
		 * errata.  If we have active commands to 3 or more
		 * devices, any error condition on active devices can
		 * corrupt DMA context switching.
		 */
		if (ap->nr_active_links >= 3) {
			ehi->err_mask |= AC_ERR_OTHER;
Tejun Heo's avatar
Tejun Heo committed
1038
			ehi->action |= ATA_EH_RESET;
1039
			ata_ehi_push_desc(ehi, "PMP DMA CS errata");
Tejun Heo's avatar
Tejun Heo committed
1040
			pp->do_port_rst = 1;
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
			freeze = 1;
		}

		/* find out the offending link and qc */
		if (ap->nr_pmp_links) {
			context = readl(port + PORT_CONTEXT);
			pmp = (context >> 5) & 0xf;

			if (pmp < ap->nr_pmp_links) {
				link = &ap->pmp_link[pmp];
				ehi = &link->eh_info;
				qc = ata_qc_from_tag(ap, link->active_tag);

				ata_ehi_clear_desc(ehi);
				ata_ehi_push_desc(ehi, "irq_stat 0x%08x",
						  irq_stat);
			} else {
				err_mask |= AC_ERR_HSM;
Tejun Heo's avatar
Tejun Heo committed
1059
				action |= ATA_EH_RESET;
1060 1061 1062 1063
				freeze = 1;
			}
		} else
			qc = ata_qc_from_tag(ap, link->active_tag);
1064 1065 1066 1067 1068 1069 1070 1071 1072

		/* analyze CMD_ERR */
		cerr = readl(port + PORT_CMD_ERR);
		if (cerr < ARRAY_SIZE(sil24_cerr_db))
			ci = &sil24_cerr_db[cerr];

		if (ci && ci->desc) {
			err_mask |= ci->err_mask;
			action |= ci->action;
Tejun Heo's avatar
Tejun Heo committed
1073
			if (action & ATA_EH_RESET)
1074
				freeze = 1;
1075
			ata_ehi_push_desc(ehi, "%s", ci->desc);
1076 1077
		} else {
			err_mask |= AC_ERR_OTHER;
Tejun Heo's avatar
Tejun Heo committed
1078
			action |= ATA_EH_RESET;
1079
			freeze = 1;
1080
			ata_ehi_push_desc(ehi, "unknown command error %d",
1081 1082 1083 1084 1085
					  cerr);
		}

		/* record error info */
		if (qc) {
1086
			sil24_read_tf(ap, qc->tag, &pp->tf);
1087 1088 1089 1090 1091
			qc->err_mask |= err_mask;
		} else
			ehi->err_mask |= err_mask;

		ehi->action |= action;
1092 1093 1094 1095

		/* if PMP, resume */
		if (ap->nr_pmp_links)
			writel(PORT_CS_PMP_RESUME, port + PORT_CTRL_STAT);
1096
	}
1097 1098 1099 1100

	/* freeze or abort */
	if (freeze)
		ata_port_freeze(ap);
1101 1102 1103 1104 1105 1106
	else if (abort) {
		if (qc)
			ata_link_abort(qc->dev->link);
		else
			ata_port_abort(ap);
	}
1107 1108
}

1109 1110
static inline void sil24_host_intr(struct ata_port *ap)
{
Tejun Heo's avatar
Tejun Heo committed
1111
	void __iomem *port = ap->ioaddr.cmd_addr;
1112 1113
	u32 slot_stat, qc_active;
	int rc;
1114

1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
	/* If PCIX_IRQ_WOC, there's an inherent race window between
	 * clearing IRQ pending status and reading PORT_SLOT_STAT
	 * which may cause spurious interrupts afterwards.  This is
	 * unavoidable and much better than losing interrupts which
	 * happens if IRQ pending is cleared after reading
	 * PORT_SLOT_STAT.
	 */
	if (ap->flags & SIL24_FLAG_PCIX_IRQ_WOC)
		writel(PORT_IRQ_COMPLETE, port + PORT_IRQ_STAT);

1125
	slot_stat = readl(port + PORT_SLOT_STAT);
1126

1127 1128 1129 1130 1131
	if (unlikely(slot_stat & HOST_SSTAT_ATTN)) {
		sil24_error_intr(ap);
		return;
	}

1132
	qc_active = slot_stat & ~HOST_SSTAT_ATTN;
1133
	rc = ata_qc_complete_multiple(ap, qc_active);
1134 1135 1136
	if (rc > 0)
		return;
	if (rc < 0) {
Tejun Heo's avatar
Tejun Heo committed
1137
		struct ata_eh_info *ehi = &ap->link.eh_info;
1138
		ehi->err_mask |= AC_ERR_HSM;
Tejun Heo's avatar
Tejun Heo committed
1139
		ehi->action |= ATA_EH_RESET;
1140
		ata_port_freeze(ap);
1141 1142 1143
		return;
	}

1144 1145
	/* spurious interrupts are expected if PCIX_IRQ_WOC */
	if (!(ap->flags & SIL24_FLAG_PCIX_IRQ_WOC) && ata_ratelimit())
1146
		ata_port_printk(ap, KERN_INFO, "spurious interrupt "
1147
			"(slot_stat 0x%x active_tag %d sactive 0x%x)\n",
Tejun Heo's avatar
Tejun Heo committed
1148
			slot_stat, ap->link.active_tag, ap->link.sactive);
1149 1150
}

1151
static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
1152
{
Jeff Garzik's avatar
Jeff Garzik committed
1153
	struct ata_host *host = dev_instance;
Tejun Heo's avatar
Tejun Heo committed
1154
	void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
1155 1156 1157 1158
	unsigned handled = 0;
	u32 status;
	int i;

Tejun Heo's avatar
Tejun Heo committed
1159
	status = readl(host_base + HOST_IRQ_STAT);
1160

1161 1162 1163 1164 1165 1166
	if (status == 0xffffffff) {
		printk(KERN_ERR DRV_NAME ": IRQ status == 0xffffffff, "
		       "PCI fault or device removal?\n");
		goto out;
	}

1167 1168 1169
	if (!(status & IRQ_STAT_4PORTS))
		goto out;

Jeff Garzik's avatar
Jeff Garzik committed
1170
	spin_lock(&host->lock);
1171

Jeff Garzik's avatar
Jeff Garzik committed
1172
	for (i = 0; i < host->n_ports; i++)
1173
		if (status & (1 << i)) {
Jeff Garzik's avatar
Jeff Garzik committed
1174
			struct ata_port *ap = host->ports[i];
1175
			if (ap && !(ap->flags & ATA_FLAG_DISABLED)) {
1176
				sil24_host_intr(ap);
1177 1178 1179 1180
				handled++;
			} else
				printk(KERN_ERR DRV_NAME
				       ": interrupt from disabled port %d\n", i);
1181 1182
		}

Jeff Garzik's avatar
Jeff Garzik committed
1183
	spin_unlock(&host->lock);
1184 1185 1186 1187
 out:
	return IRQ_RETVAL(handled);
}

1188 1189
static void sil24_error_handler(struct ata_port *ap)
{
Tejun Heo's avatar
Tejun Heo committed
1190 1191
	struct sil24_port_priv *pp = ap->private_data;

1192
	if (sil24_init_port(ap))
1193 1194
		ata_eh_freeze_port(ap);

1195
	sata_pmp_error_handler(ap);
Tejun Heo's avatar
Tejun Heo committed
1196 1197

	pp->do_port_rst = 0;
1198 1199 1200 1201 1202 1203 1204
}

static void sil24_post_internal_cmd(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;

	/* make DMA engine forget about the failed command */
1205 1206
	if ((qc->flags & ATA_QCFLAG_FAILED) && sil24_init_port(ap))
		ata_eh_freeze_port(ap);
1207 1208
}

1209 1210
static int sil24_port_start(struct ata_port *ap)
{
Jeff Garzik's avatar
Jeff Garzik committed
1211
	struct device *dev = ap->host->dev;
1212
	struct sil24_port_priv *pp;
Tejun Heo's avatar
Tejun Heo committed
1213
	union sil24_cmd_block *cb;
1214
	size_t cb_size = sizeof(*cb) * SIL24_MAX_CMDS;
1215 1216
	dma_addr_t cb_dma;

1217
	pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
1218
	if (!pp)
1219
		return -ENOMEM;
1220

1221 1222
	pp->tf.command = ATA_DRDY;

1223
	cb = dmam_alloc_coherent(dev, cb_size, &cb_dma, GFP_KERNEL);
1224
	if (!cb)
1225
		return -ENOMEM;
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
	memset(cb, 0, cb_size);

	pp->cmd_block = cb;
	pp->cmd_block_dma = cb_dma;

	ap->private_data = pp;

	return 0;
}

1236
static void sil24_init_controller(struct ata_host *host)
1237
{
1238
	void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
	u32 tmp;
	int i;

	/* GPIO off */
	writel(0, host_base + HOST_FLASH_CMD);

	/* clear global reset & mask interrupts during initialization */
	writel(0, host_base + HOST_CTRL);

	/* init ports */
1249
	for (i = 0; i < host->n_ports; i++) {
Tejun Heo's avatar
Tejun Heo committed
1250 1251
		struct ata_port *ap = host->ports[i];
		void __iomem *port = ap->ioaddr.cmd_addr;
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263

		/* Initial PHY setting */
		writel(0x20c, port + PORT_PHY_CFG);

		/* Clear port RST */
		tmp = readl(port + PORT_CTRL_STAT);
		if (tmp & PORT_CS_PORT_RST) {
			writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
			tmp = ata_wait_register(port + PORT_CTRL_STAT,
						PORT_CS_PORT_RST,
						PORT_CS_PORT_RST, 10, 100);
			if (tmp & PORT_CS_PORT_RST)
1264
				dev_printk(KERN_ERR, host->dev,
1265
					   "failed to clear port RST\n");
1266 1267
		}

Tejun Heo's avatar
Tejun Heo committed
1268 1269
		/* configure port */
		sil24_config_port(ap);
1270 1271 1272 1273 1274 1275
	}

	/* Turn on interrupts */
	writel(IRQ_STAT_4PORTS, host_base + HOST_CTRL);
}

1276 1277
static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
{
Tejun Heo's avatar
Tejun Heo committed
1278
	extern int __MARKER__sil24_cmd_block_is_sized_wrongly;
1279
	static int printed_version;
1280 1281 1282 1283
	struct ata_port_info pi = sil24_port_info[ent->driver_data];
	const struct ata_port_info *ppi[] = { &pi, NULL };
	void __iomem * const *iomap;
	struct ata_host *host;
1284
	int i, rc;
1285
	u32 tmp;
1286

Tejun Heo's avatar
Tejun Heo committed
1287 1288 1289 1290
	/* cause link error if sil24_cmd_block is sized wrongly */
	if (sizeof(union sil24_cmd_block) != PAGE_SIZE)
		__MARKER__sil24_cmd_block_is_sized_wrongly = 1;

1291
	if (!printed_version++)
1292
		dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
1293

1294
	/* acquire resources */
1295
	rc = pcim_enable_device(pdev);
1296 1297 1298
	if (rc)
		return rc;

Tejun Heo's avatar
Tejun Heo committed
1299 1300 1301
	rc = pcim_iomap_regions(pdev,
				(1 << SIL24_HOST_BAR) | (1 << SIL24_PORT_BAR),
				DRV_NAME);
1302
	if (rc)
1303
		return rc;
1304
	iomap = pcim_iomap_table(pdev);
1305

1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
	/* apply workaround for completion IRQ loss on PCI-X errata */
	if (pi.flags & SIL24_FLAG_PCIX_IRQ_WOC) {
		tmp = readl(iomap[SIL24_HOST_BAR] + HOST_CTRL);
		if (tmp & (HOST_CTRL_TRDY | HOST_CTRL_STOP | HOST_CTRL_DEVSEL))
			dev_printk(KERN_INFO, &pdev->dev,
				   "Applying completion IRQ loss on PCI-X "
				   "errata fix\n");
		else
			pi.flags &= ~SIL24_FLAG_PCIX_IRQ_WOC;
	}
1316

1317 1318 1319 1320 1321 1322
	/* allocate and fill host */
	host = ata_host_alloc_pinfo(&pdev->dev, ppi,
				    SIL24_FLAG2NPORTS(ppi[0]->flags));
	if (!host)
		return -ENOMEM;
	host->iomap = iomap;
1323

1324
	for (i = 0; i < host->n_ports; i++) {
1325 1326 1327
		struct ata_port *ap = host->ports[i];
		size_t offset = ap->port_no * PORT_REGS_SIZE;
		void __iomem *port = iomap[SIL24_PORT_BAR] + offset;
1328

1329 1330
		host->ports[i]->ioaddr.cmd_addr = port;
		host->ports[i]->ioaddr.scr_addr = port + PORT_SCONTROL;
1331

1332 1333
		ata_port_pbar_desc(ap, SIL24_HOST_BAR, -1, "host");
		ata_port_pbar_desc(ap, SIL24_PORT_BAR, offset, "port");
1334
	}
1335

1336
	/* configure and activate the device */
Tejun Heo's avatar
Tejun Heo committed
1337 1338 1339 1340 1341 1342 1343
	if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
		rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
		if (rc) {
			rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
			if (rc) {
				dev_printk(KERN_ERR, &pdev->dev,
					   "64-bit DMA enable failed\n");
1344
				return rc;
Tejun Heo's avatar
Tejun Heo committed
1345 1346 1347 1348 1349 1350 1351
			}
		}
	} else {
		rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
		if (rc) {
			dev_printk(KERN_ERR, &pdev->dev,
				   "32-bit DMA enable failed\n");
1352
			return rc;
Tejun Heo's avatar
Tejun Heo committed
1353 1354 1355 1356 1357
		}
		rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
		if (rc) {
			dev_printk(KERN_ERR, &pdev->dev,
				   "32-bit consistent DMA enable failed\n");
1358
			return rc;
Tejun Heo's avatar
Tejun Heo committed
1359
		}
1360 1361
	}

1362
	sil24_init_controller(host);
1363 1364

	pci_set_master(pdev);
1365 1366
	return ata_host_activate(host, pdev->irq, sil24_interrupt, IRQF_SHARED,
				 &sil24_sht);
1367 1368
}

1369
#ifdef CONFIG_PM
1370 1371
static int sil24_pci_device_resume(struct pci_dev *pdev)
{
Jeff Garzik's avatar
Jeff Garzik committed
1372
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
Tejun Heo's avatar
Tejun Heo committed
1373
	void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
1374
	int rc;
1375

1376 1377 1378
	rc = ata_pci_device_do_resume(pdev);
	if (rc)
		return rc;
1379 1380

	if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND)
Tejun Heo's avatar
Tejun Heo committed
1381
		writel(HOST_CTRL_GLOBAL_RST, host_base + HOST_CTRL);
1382

1383
	sil24_init_controller(host);
1384

Jeff Garzik's avatar
Jeff Garzik committed
1385
	ata_host_resume(host);
1386 1387 1388

	return 0;
}
1389 1390 1391 1392 1393 1394

static int sil24_port_resume(struct ata_port *ap)
{
	sil24_config_pmp(ap, ap->nr_pmp_links);
	return 0;
}
1395
#endif
1396

1397 1398
static int __init sil24_init(void)
{
1399
	return pci_register_driver(&sil24_pci_driver);
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
}

static void __exit sil24_exit(void)
{
	pci_unregister_driver(&sil24_pci_driver);
}

MODULE_AUTHOR("Tejun Heo");
MODULE_DESCRIPTION("Silicon Image 3124/3132 SATA low-level driver");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, sil24_pci_tbl);

module_init(sil24_init);
module_exit(sil24_exit);