sata_sil24.c 30.9 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"
Jeff Garzik's avatar
Jeff Garzik committed
33
#define DRV_VERSION	"0.9"
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,

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
	/*
	 * 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),

91 92 93 94 95 96
	/* 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 */
97
	HOST_CTRL_GLOBAL_RST	= (1 << 31), /* global reset */
98

99 100 101 102 103
	/*
	 * Port registers
	 * (8192 bytes @ +0x0000, +0x2000, +0x4000 and +0x6000 @ BAR2)
	 */
	PORT_REGS_SIZE		= 0x2000,
104

105
	PORT_LRAM		= 0x0000, /* 31 LRAM slots and PMP regs */
106
	PORT_LRAM_SLOT_SZ	= 0x0080, /* 32 bytes PRB + 2 SGE, ACT... */
107

108
	PORT_PMP		= 0x0f80, /* 8 bytes PMP * 16 (128 bytes) */
109 110 111 112
	PORT_PMP_STATUS		= 0x0000, /* port device status offset */
	PORT_PMP_QACTIVE	= 0x0004, /* port device QActive offset */
	PORT_PMP_SIZE		= 0x0008, /* 8 bytes per PMP */

113
		/* 32 bit regs */
114 115 116 117 118
	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 */
119
	PORT_ACTIVATE_UPPER_ADDR= 0x101c,
120 121
	PORT_EXEC_FIFO		= 0x1020, /* command execution fifo */
	PORT_CMD_ERR		= 0x1024, /* command error number */
122 123 124 125 126 127 128 129 130 131 132 133 134
	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) */
135
	PORT_CONTEXT		= 0x1e04,
136 137 138 139 140 141 142 143 144 145 146 147
	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
148
	PORT_CS_CDB16		= (1 << 5), /* 0=12b cdb, 1=16b cdb */
149
	PORT_CS_PMP_RESUME	= (1 << 6), /* PMP resume */
150
	PORT_CS_32BIT_ACTV	= (1 << 10), /* 32-bit activation */
151
	PORT_CS_PMP_EN		= (1 << 13), /* port multiplier enable */
152
	PORT_CS_RDY		= (1 << 31), /* port ready to accept commands */
153 154 155 156 157 158 159 160 161

	/* 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 */
162 163 164 165 166
	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 */
167
	PORT_IRQ_SDB_NOTIFY	= (1 << 11), /* SDB notify received */
168

169
	DEF_PORT_IRQ		= PORT_IRQ_COMPLETE | PORT_IRQ_ERROR |
170 171
				  PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG |
				  PORT_IRQ_UNK_FIS,
172

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
	/* 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
202
	PORT_CERR_XFR_MSTABRT	= 34, /* PSD ecode 10 - master abort */
203
	PORT_CERR_XFR_PCIPERR	= 35, /* PSD ecode 11 - PCI prity err during transfer */
204
	PORT_CERR_SENDSERVICE	= 36, /* FIS received while sending service */
205

Tejun Heo's avatar
Tejun Heo committed
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
	/* 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),

221 222 223 224
	/*
	 * Other constants
	 */
	SGE_TRM			= (1 << 31), /* Last SGE in chain */
Tejun Heo's avatar
Tejun Heo committed
225 226 227 228
	SGE_LNK			= (1 << 30), /* linked list
						Points to SGT, not SGE */
	SGE_DRD			= (1 << 29), /* discard data read (/dev/null)
						data address ignored */
229

230 231
	SIL24_MAX_CMDS		= 31,

232 233 234
	/* board id */
	BID_SIL3124		= 0,
	BID_SIL3132		= 1,
235
	BID_SIL3131		= 2,
236

237 238
	/* host flags */
	SIL24_COMMON_FLAGS	= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
239
				  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
240 241
				  ATA_FLAG_NCQ | ATA_FLAG_SKIP_D2H_BSY |
				  ATA_FLAG_ACPI_SATA,
242
	SIL24_FLAG_PCIX_IRQ_WOC	= (1 << 24), /* IRQ loss errata on PCI-X */
243

244 245 246
	IRQ_STAT_4PORTS		= 0xf,
};

Tejun Heo's avatar
Tejun Heo committed
247
struct sil24_ata_block {
248 249 250 251
	struct sil24_prb prb;
	struct sil24_sge sge[LIBATA_MAX_PRD];
};

Tejun Heo's avatar
Tejun Heo committed
252 253 254 255 256 257 258 259 260 261 262
struct sil24_atapi_block {
	struct sil24_prb prb;
	u8 cdb[16];
	struct sil24_sge sge[LIBATA_MAX_PRD - 1];
};

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

263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
static struct sil24_cerr_info {
	unsigned int err_mask, action;
	const char *desc;
} sil24_cerr_db[] = {
	[0]			= { AC_ERR_DEV, ATA_EH_REVALIDATE,
				    "device error" },
	[PORT_CERR_DEV]		= { AC_ERR_DEV, ATA_EH_REVALIDATE,
				    "device error via D2H FIS" },
	[PORT_CERR_SDB]		= { AC_ERR_DEV, ATA_EH_REVALIDATE,
				    "device error via SDB FIS" },
	[PORT_CERR_DATA]	= { AC_ERR_ATA_BUS, ATA_EH_SOFTRESET,
				    "error in data FIS" },
	[PORT_CERR_SEND]	= { AC_ERR_ATA_BUS, ATA_EH_SOFTRESET,
				    "failed to transmit command FIS" },
	[PORT_CERR_INCONSISTENT] = { AC_ERR_HSM, ATA_EH_SOFTRESET,
				     "protocol mismatch" },
	[PORT_CERR_DIRECTION]	= { AC_ERR_HSM, ATA_EH_SOFTRESET,
				    "data directon mismatch" },
	[PORT_CERR_UNDERRUN]	= { AC_ERR_HSM, ATA_EH_SOFTRESET,
				    "ran out of SGEs while writing" },
	[PORT_CERR_OVERRUN]	= { AC_ERR_HSM, ATA_EH_SOFTRESET,
				    "ran out of SGEs while reading" },
	[PORT_CERR_PKT_PROT]	= { AC_ERR_HSM, ATA_EH_SOFTRESET,
				    "invalid data directon for ATAPI CDB" },
	[PORT_CERR_SGT_BOUNDARY] = { AC_ERR_SYSTEM, ATA_EH_SOFTRESET,
				     "SGT no on qword boundary" },
	[PORT_CERR_SGT_TGTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI target abort while fetching SGT" },
	[PORT_CERR_SGT_MSTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI master abort while fetching SGT" },
	[PORT_CERR_SGT_PCIPERR]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI parity error while fetching SGT" },
	[PORT_CERR_CMD_BOUNDARY] = { AC_ERR_SYSTEM, ATA_EH_SOFTRESET,
				     "PRB not on qword boundary" },
	[PORT_CERR_CMD_TGTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI target abort while fetching PRB" },
	[PORT_CERR_CMD_MSTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI master abort while fetching PRB" },
	[PORT_CERR_CMD_PCIPERR]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI parity error while fetching PRB" },
	[PORT_CERR_XFR_UNDEF]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "undefined error while transferring data" },
	[PORT_CERR_XFR_TGTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI target abort while transferring data" },
	[PORT_CERR_XFR_MSTABRT]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI master abort while transferring data" },
	[PORT_CERR_XFR_PCIPERR]	= { AC_ERR_HOST_BUS, ATA_EH_SOFTRESET,
				    "PCI parity error while transferring data" },
	[PORT_CERR_SENDSERVICE]	= { AC_ERR_HSM, ATA_EH_SOFTRESET,
				    "FIS received while sending service FIS" },
};

315 316 317 318 319 320 321
/*
 * 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
322
	union sil24_cmd_block *cmd_block;	/* 32 cmd blocks */
323
	dma_addr_t cmd_block_dma;		/* DMA base addr for them */
324
	struct ata_taskfile tf;			/* Cached taskfile registers */
325 326
};

327
static void sil24_dev_config(struct ata_device *dev);
328 329 330
static u8 sil24_check_status(struct ata_port *ap);
static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg);
static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
331
static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
332
static void sil24_qc_prep(struct ata_queued_cmd *qc);
333
static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
334
static void sil24_irq_clear(struct ata_port *ap);
335 336 337 338
static void sil24_freeze(struct ata_port *ap);
static void sil24_thaw(struct ata_port *ap);
static void sil24_error_handler(struct ata_port *ap);
static void sil24_post_internal_cmd(struct ata_queued_cmd *qc);
339 340
static int sil24_port_start(struct ata_port *ap);
static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
341
#ifdef CONFIG_PM
342
static int sil24_pci_device_resume(struct pci_dev *pdev);
343
#endif
344

345
static const struct pci_device_id sil24_pci_tbl[] = {
346 347 348
	{ PCI_VDEVICE(CMD, 0x3124), BID_SIL3124 },
	{ PCI_VDEVICE(INTEL, 0x3124), BID_SIL3124 },
	{ PCI_VDEVICE(CMD, 0x3132), BID_SIL3132 },
349
	{ PCI_VDEVICE(CMD, 0x0242), BID_SIL3132 },
350 351 352
	{ PCI_VDEVICE(CMD, 0x3131), BID_SIL3131 },
	{ PCI_VDEVICE(CMD, 0x3531), BID_SIL3131 },

Tejun Heo's avatar
Tejun Heo committed
353
	{ } /* terminate list */
354 355 356 357 358 359
};

static struct pci_driver sil24_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= sil24_pci_tbl,
	.probe			= sil24_init_one,
360
	.remove			= ata_pci_remove_one,
361
#ifdef CONFIG_PM
362 363
	.suspend		= ata_pci_device_suspend,
	.resume			= sil24_pci_device_resume,
364
#endif
365 366
};

367
static struct scsi_host_template sil24_sht = {
368 369 370 371
	.module			= THIS_MODULE,
	.name			= DRV_NAME,
	.ioctl			= ata_scsi_ioctl,
	.queuecommand		= ata_scsi_queuecmd,
372 373
	.change_queue_depth	= ata_scsi_change_queue_depth,
	.can_queue		= SIL24_MAX_CMDS,
374 375 376 377 378 379 380 381
	.this_id		= ATA_SHT_THIS_ID,
	.sg_tablesize		= LIBATA_MAX_PRD,
	.cmd_per_lun		= ATA_SHT_CMD_PER_LUN,
	.emulated		= ATA_SHT_EMULATED,
	.use_clustering		= ATA_SHT_USE_CLUSTERING,
	.proc_name		= DRV_NAME,
	.dma_boundary		= ATA_DMA_BOUNDARY,
	.slave_configure	= ata_scsi_slave_config,
Tejun Heo's avatar
Tejun Heo committed
382
	.slave_destroy		= ata_scsi_slave_destroy,
383 384 385
	.bios_param		= ata_std_bios_param,
};

386
static const struct ata_port_operations sil24_ops = {
387 388
	.port_disable		= ata_port_disable,

Tejun Heo's avatar
Tejun Heo committed
389 390
	.dev_config		= sil24_dev_config,

391 392 393 394
	.check_status		= sil24_check_status,
	.check_altstatus	= sil24_check_status,
	.dev_select		= ata_noop_dev_select,

395 396
	.tf_read		= sil24_tf_read,

397 398 399 400
	.qc_prep		= sil24_qc_prep,
	.qc_issue		= sil24_qc_issue,

	.irq_clear		= sil24_irq_clear,
401 402
	.irq_on			= ata_dummy_irq_on,
	.irq_ack		= ata_dummy_irq_ack,
403 404 405 406

	.scr_read		= sil24_scr_read,
	.scr_write		= sil24_scr_write,

407 408 409 410 411
	.freeze			= sil24_freeze,
	.thaw			= sil24_thaw,
	.error_handler		= sil24_error_handler,
	.post_internal_cmd	= sil24_post_internal_cmd,

412 413 414
	.port_start		= sil24_port_start,
};

415
/*
Jeff Garzik's avatar
Jeff Garzik committed
416
 * Use bits 30-31 of port_flags to encode available port numbers.
417 418 419 420 421
 * Current maxium is 4.
 */
#define SIL24_NPORTS2FLAG(nports)	((((unsigned)(nports) - 1) & 0x3) << 30)
#define SIL24_FLAG2NPORTS(flag)		((((flag) >> 30) & 0x3) + 1)

422
static const struct ata_port_info sil24_port_info[] = {
423 424
	/* sil_3124 */
	{
Jeff Garzik's avatar
Jeff Garzik committed
425
		.flags		= SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(4) |
426
				  SIL24_FLAG_PCIX_IRQ_WOC,
427 428 429 430 431
		.pio_mask	= 0x1f,			/* pio0-4 */
		.mwdma_mask	= 0x07,			/* mwdma0-2 */
		.udma_mask	= 0x3f,			/* udma0-5 */
		.port_ops	= &sil24_ops,
	},
432
	/* sil_3132 */
433
	{
Jeff Garzik's avatar
Jeff Garzik committed
434
		.flags		= SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(2),
435 436 437 438 439 440 441
		.pio_mask	= 0x1f,			/* pio0-4 */
		.mwdma_mask	= 0x07,			/* mwdma0-2 */
		.udma_mask	= 0x3f,			/* udma0-5 */
		.port_ops	= &sil24_ops,
	},
	/* sil_3131/sil_3531 */
	{
Jeff Garzik's avatar
Jeff Garzik committed
442
		.flags		= SIL24_COMMON_FLAGS | SIL24_NPORTS2FLAG(1),
443 444 445 446 447 448 449
		.pio_mask	= 0x1f,			/* pio0-4 */
		.mwdma_mask	= 0x07,			/* mwdma0-2 */
		.udma_mask	= 0x3f,			/* udma0-5 */
		.port_ops	= &sil24_ops,
	},
};

450 451 452 453 454 455 456
static int sil24_tag(int tag)
{
	if (unlikely(ata_tag_internal(tag)))
		return 0;
	return tag;
}

457
static void sil24_dev_config(struct ata_device *dev)
Tejun Heo's avatar
Tejun Heo committed
458
{
459
	void __iomem *port = dev->ap->ioaddr.cmd_addr;
Tejun Heo's avatar
Tejun Heo committed
460

461
	if (dev->cdb_len == 16)
Tejun Heo's avatar
Tejun Heo committed
462 463 464 465 466
		writel(PORT_CS_CDB16, port + PORT_CTRL_STAT);
	else
		writel(PORT_CS_CDB16, port + PORT_CTRL_CLR);
}

467 468 469
static inline void sil24_update_tf(struct ata_port *ap)
{
	struct sil24_port_priv *pp = ap->private_data;
Tejun Heo's avatar
Tejun Heo committed
470
	void __iomem *port = ap->ioaddr.cmd_addr;
471 472
	struct sil24_prb __iomem *prb = port;
	u8 fis[6 * 4];
473

474 475
	memcpy_fromio(fis, prb->fis, 6 * 4);
	ata_tf_from_fis(fis, &pp->tf);
476 477
}

478 479
static u8 sil24_check_status(struct ata_port *ap)
{
480 481
	struct sil24_port_priv *pp = ap->private_data;
	return pp->tf.command;
482 483 484 485 486 487 488 489 490 491 492
}

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

static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg)
{
Tejun Heo's avatar
Tejun Heo committed
493
	void __iomem *scr_addr = ap->ioaddr.scr_addr;
494
	if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
495
		void __iomem *addr;
496 497 498 499 500 501 502 503
		addr = scr_addr + sil24_scr_map[sc_reg] * 4;
		return readl(scr_addr + sil24_scr_map[sc_reg] * 4);
	}
	return 0xffffffffU;
}

static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
{
Tejun Heo's avatar
Tejun Heo committed
504
	void __iomem *scr_addr = ap->ioaddr.scr_addr;
505
	if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
506
		void __iomem *addr;
507 508 509 510 511
		addr = scr_addr + sil24_scr_map[sc_reg] * 4;
		writel(val, scr_addr + sil24_scr_map[sc_reg] * 4);
	}
}

512 513 514 515 516 517
static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
{
	struct sil24_port_priv *pp = ap->private_data;
	*tf = pp->tf;
}

518 519
static int sil24_init_port(struct ata_port *ap)
{
Tejun Heo's avatar
Tejun Heo committed
520
	void __iomem *port = ap->ioaddr.cmd_addr;
521 522 523 524 525 526 527 528 529 530 531 532 533
	u32 tmp;

	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);

	if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY)
		return -EIO;
	return 0;
}

534 535
static int sil24_softreset(struct ata_port *ap, unsigned int *class,
			   unsigned long deadline)
536
{
Tejun Heo's avatar
Tejun Heo committed
537
	void __iomem *port = ap->ioaddr.cmd_addr;
538
	struct sil24_port_priv *pp = ap->private_data;
Tejun Heo's avatar
Tejun Heo committed
539
	struct sil24_prb *prb = &pp->cmd_block[0].ata.prb;
540
	dma_addr_t paddr = pp->cmd_block_dma;
541
	u32 mask, irq_stat;
542
	const char *reason;
543

544 545
	DPRINTK("ENTER\n");

546
	if (ata_port_offline(ap)) {
547 548 549 550 551
		DPRINTK("PHY reports no device\n");
		*class = ATA_DEV_NONE;
		goto out;
	}

552 553 554 555 556 557
	/* put the port into known state */
	if (sil24_init_port(ap)) {
		reason ="port not ready";
		goto err;
	}

558
	/* do SRST */
559
	prb->ctrl = cpu_to_le16(PRB_CTRL_SRST);
560
	prb->fis[1] = 0; /* no PMP yet */
561 562

	writel((u32)paddr, port + PORT_CMD_ACTIVATE);
Tejun Heo's avatar
Tejun Heo committed
563
	writel((u64)paddr >> 32, port + PORT_CMD_ACTIVATE + 4);
564

565 566
	mask = (PORT_IRQ_COMPLETE | PORT_IRQ_ERROR) << PORT_IRQ_RAW_SHIFT;
	irq_stat = ata_wait_register(port + PORT_IRQ_STAT, mask, 0x0,
567
				     100, jiffies_to_msecs(deadline - jiffies));
568

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

572
	if (!(irq_stat & PORT_IRQ_COMPLETE)) {
573 574 575 576 577
		if (irq_stat & PORT_IRQ_ERROR)
			reason = "SRST command error";
		else
			reason = "timeout";
		goto err;
578
	}
579 580 581 582

	sil24_update_tf(ap);
	*class = ata_dev_classify(&pp->tf);

583 584
	if (*class == ATA_DEV_UNKNOWN)
		*class = ATA_DEV_NONE;
585

586
 out:
587
	DPRINTK("EXIT, class=%u\n", *class);
588
	return 0;
589 590

 err:
591
	ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
592
	return -EIO;
593 594
}

595 596
static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
			   unsigned long deadline)
Tejun Heo's avatar
Tejun Heo committed
597
{
Tejun Heo's avatar
Tejun Heo committed
598
	void __iomem *port = ap->ioaddr.cmd_addr;
599
	const char *reason;
600
	int tout_msec, rc;
601 602 603
	u32 tmp;

	/* sil24 does the right thing(tm) without any protection */
604
	sata_set_spd(ap);
605 606

	tout_msec = 100;
607
	if (ata_port_online(ap))
608 609 610 611 612 613
		tout_msec = 5000;

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

614 615
	/* SStatus oscillates between zero and valid status after
	 * DEV_RST, debounce it.
616
	 */
617
	rc = sata_phy_debounce(ap, sata_deb_timing_long, deadline);
618 619 620 621
	if (rc) {
		reason = "PHY debouncing failed";
		goto err;
	}
622 623

	if (tmp & PORT_CS_DEV_RST) {
624
		if (ata_port_offline(ap))
625 626 627 628 629
			return 0;
		reason = "link not ready";
		goto err;
	}

630 631 632 633 634
	/* 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.
635
	 */
636
	return -EAGAIN;
637 638

 err:
639
	ata_port_printk(ap, KERN_ERR, "hardreset failed (%s)\n", reason);
640
	return -EIO;
Tejun Heo's avatar
Tejun Heo committed
641 642
}

643
static inline void sil24_fill_sg(struct ata_queued_cmd *qc,
Tejun Heo's avatar
Tejun Heo committed
644
				 struct sil24_sge *sge)
645
{
646
	struct scatterlist *sg;
647

648
	ata_for_each_sg(sg, qc) {
649 650
		sge->addr = cpu_to_le64(sg_dma_address(sg));
		sge->cnt = cpu_to_le32(sg_dma_len(sg));
651 652 653 654 655
		if (ata_sg_is_last(sg, qc))
			sge->flags = cpu_to_le32(SGE_TRM);
		else
			sge->flags = 0;
		sge++;
656 657 658 659 660 661 662
	}
}

static void sil24_qc_prep(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	struct sil24_port_priv *pp = ap->private_data;
663
	union sil24_cmd_block *cb;
Tejun Heo's avatar
Tejun Heo committed
664 665
	struct sil24_prb *prb;
	struct sil24_sge *sge;
666
	u16 ctrl = 0;
667

668 669
	cb = &pp->cmd_block[sil24_tag(qc->tag)];

670 671 672
	switch (qc->tf.protocol) {
	case ATA_PROT_PIO:
	case ATA_PROT_DMA:
673
	case ATA_PROT_NCQ:
674
	case ATA_PROT_NODATA:
Tejun Heo's avatar
Tejun Heo committed
675 676
		prb = &cb->ata.prb;
		sge = cb->ata.sge;
677
		break;
Tejun Heo's avatar
Tejun Heo committed
678 679 680 681 682 683 684

	case ATA_PROT_ATAPI:
	case ATA_PROT_ATAPI_DMA:
	case ATA_PROT_ATAPI_NODATA:
		prb = &cb->atapi.prb;
		sge = cb->atapi.sge;
		memset(cb->atapi.cdb, 0, 32);
685
		memcpy(cb->atapi.cdb, qc->cdb, qc->dev->cdb_len);
Tejun Heo's avatar
Tejun Heo committed
686 687 688

		if (qc->tf.protocol != ATA_PROT_ATAPI_NODATA) {
			if (qc->tf.flags & ATA_TFLAG_WRITE)
689
				ctrl = PRB_CTRL_PACKET_WRITE;
Tejun Heo's avatar
Tejun Heo committed
690
			else
691 692
				ctrl = PRB_CTRL_PACKET_READ;
		}
Tejun Heo's avatar
Tejun Heo committed
693 694
		break;

695
	default:
Tejun Heo's avatar
Tejun Heo committed
696 697
		prb = NULL;	/* shut up, gcc */
		sge = NULL;
698 699 700
		BUG();
	}

701
	prb->ctrl = cpu_to_le16(ctrl);
702 703 704
	ata_tf_to_fis(&qc->tf, prb->fis, 0);

	if (qc->flags & ATA_QCFLAG_DMAMAP)
Tejun Heo's avatar
Tejun Heo committed
705
		sil24_fill_sg(qc, sge);
706 707
}

708
static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc)
709 710 711
{
	struct ata_port *ap = qc->ap;
	struct sil24_port_priv *pp = ap->private_data;
Tejun Heo's avatar
Tejun Heo committed
712
	void __iomem *port = ap->ioaddr.cmd_addr;
713 714 715
	unsigned int tag = sil24_tag(qc->tag);
	dma_addr_t paddr;
	void __iomem *activate;
716

717 718 719 720 721
	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
722

723 724 725 726 727 728 729 730
	return 0;
}

static void sil24_irq_clear(struct ata_port *ap)
{
	/* unused */
}

731
static void sil24_freeze(struct ata_port *ap)
732
{
Tejun Heo's avatar
Tejun Heo committed
733
	void __iomem *port = ap->ioaddr.cmd_addr;
734

735 736 737 738
	/* Port-wide IRQ mask in HOST_CTRL doesn't really work, clear
	 * PORT_IRQ_ENABLE instead.
	 */
	writel(0xffff, port + PORT_IRQ_ENABLE_CLR);
739 740
}

741
static void sil24_thaw(struct ata_port *ap)
742
{
Tejun Heo's avatar
Tejun Heo committed
743
	void __iomem *port = ap->ioaddr.cmd_addr;
744 745
	u32 tmp;

746 747 748
	/* clear IRQ */
	tmp = readl(port + PORT_IRQ_STAT);
	writel(tmp, port + PORT_IRQ_STAT);
749

750 751
	/* turn IRQ back on */
	writel(DEF_PORT_IRQ, port + PORT_IRQ_ENABLE_SET);
752 753
}

754
static void sil24_error_intr(struct ata_port *ap)
755
{
Tejun Heo's avatar
Tejun Heo committed
756
	void __iomem *port = ap->ioaddr.cmd_addr;
757 758 759
	struct ata_eh_info *ehi = &ap->eh_info;
	int freeze = 0;
	u32 irq_stat;
760

761
	/* on error, we need to clear IRQ explicitly */
762
	irq_stat = readl(port + PORT_IRQ_STAT);
763
	writel(irq_stat, port + PORT_IRQ_STAT);
764

765 766
	/* first, analyze and record host port events */
	ata_ehi_clear_desc(ehi);
767

768
	ata_ehi_push_desc(ehi, "irq_stat 0x%08x", irq_stat);
769

770 771 772 773 774
	if (irq_stat & (PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG)) {
		ata_ehi_hotplugged(ehi);
		ata_ehi_push_desc(ehi, ", %s",
			       irq_stat & PORT_IRQ_PHYRDY_CHG ?
			       "PHY RDY changed" : "device exchanged");
775
		freeze = 1;
776 777
	}

778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
	if (irq_stat & PORT_IRQ_UNK_FIS) {
		ehi->err_mask |= AC_ERR_HSM;
		ehi->action |= ATA_EH_SOFTRESET;
		ata_ehi_push_desc(ehi , ", unknown FIS");
		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;
		struct ata_queued_cmd *qc;
		u32 cerr;

		/* 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;
			ata_ehi_push_desc(ehi, ", %s", ci->desc);
		} else {
			err_mask |= AC_ERR_OTHER;
			action |= ATA_EH_SOFTRESET;
			ata_ehi_push_desc(ehi, ", unknown command error %d",
					  cerr);
		}

		/* record error info */
		qc = ata_qc_from_tag(ap, ap->active_tag);
		if (qc) {
			sil24_update_tf(ap);
			qc->err_mask |= err_mask;
		} else
			ehi->err_mask |= err_mask;

		ehi->action |= action;
817
	}
818 819 820 821 822 823

	/* freeze or abort */
	if (freeze)
		ata_port_freeze(ap);
	else
		ata_port_abort(ap);
824 825
}

826 827 828 829 830 831
static void sil24_finish_qc(struct ata_queued_cmd *qc)
{
	if (qc->flags & ATA_QCFLAG_RESULT_TF)
		sil24_update_tf(qc->ap);
}

832 833
static inline void sil24_host_intr(struct ata_port *ap)
{
Tejun Heo's avatar
Tejun Heo committed
834
	void __iomem *port = ap->ioaddr.cmd_addr;
835 836
	u32 slot_stat, qc_active;
	int rc;
837 838

	slot_stat = readl(port + PORT_SLOT_STAT);
839

840 841 842 843 844 845 846
	if (unlikely(slot_stat & HOST_SSTAT_ATTN)) {
		sil24_error_intr(ap);
		return;
	}

	if (ap->flags & SIL24_FLAG_PCIX_IRQ_WOC)
		writel(PORT_IRQ_COMPLETE, port + PORT_IRQ_STAT);
847

848 849 850 851 852 853 854 855 856
	qc_active = slot_stat & ~HOST_SSTAT_ATTN;
	rc = ata_qc_complete_multiple(ap, qc_active, sil24_finish_qc);
	if (rc > 0)
		return;
	if (rc < 0) {
		struct ata_eh_info *ehi = &ap->eh_info;
		ehi->err_mask |= AC_ERR_HSM;
		ehi->action |= ATA_EH_SOFTRESET;
		ata_port_freeze(ap);
857 858 859 860 861
		return;
	}

	if (ata_ratelimit())
		ata_port_printk(ap, KERN_INFO, "spurious interrupt "
862 863
			"(slot_stat 0x%x active_tag %d sactive 0x%x)\n",
			slot_stat, ap->active_tag, ap->sactive);
864 865
}

866
static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
867
{
Jeff Garzik's avatar
Jeff Garzik committed
868
	struct ata_host *host = dev_instance;
Tejun Heo's avatar
Tejun Heo committed
869
	void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
870 871 872 873
	unsigned handled = 0;
	u32 status;
	int i;

Tejun Heo's avatar
Tejun Heo committed
874
	status = readl(host_base + HOST_IRQ_STAT);
875

876 877 878 879 880 881
	if (status == 0xffffffff) {
		printk(KERN_ERR DRV_NAME ": IRQ status == 0xffffffff, "
		       "PCI fault or device removal?\n");
		goto out;
	}

882 883 884
	if (!(status & IRQ_STAT_4PORTS))
		goto out;

Jeff Garzik's avatar
Jeff Garzik committed
885
	spin_lock(&host->lock);
886

Jeff Garzik's avatar
Jeff Garzik committed
887
	for (i = 0; i < host->n_ports; i++)
888
		if (status & (1 << i)) {
Jeff Garzik's avatar
Jeff Garzik committed
889
			struct ata_port *ap = host->ports[i];
890
			if (ap && !(ap->flags & ATA_FLAG_DISABLED)) {
891
				sil24_host_intr(ap);
892 893 894 895
				handled++;
			} else
				printk(KERN_ERR DRV_NAME
				       ": interrupt from disabled port %d\n", i);
896 897
		}

Jeff Garzik's avatar
Jeff Garzik committed
898
	spin_unlock(&host->lock);
899 900 901 902
 out:
	return IRQ_RETVAL(handled);
}

903 904 905 906 907 908 909 910 911 912
static void sil24_error_handler(struct ata_port *ap)
{
	struct ata_eh_context *ehc = &ap->eh_context;

	if (sil24_init_port(ap)) {
		ata_eh_freeze_port(ap);
		ehc->i.action |= ATA_EH_HARDRESET;
	}

	/* perform recovery */
913 914
	ata_do_eh(ap, ata_std_prereset, sil24_softreset, sil24_hardreset,
		  ata_std_postreset);
915 916 917 918 919 920 921
}

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 */
922
	if (qc->flags & ATA_QCFLAG_FAILED)
923 924 925
		sil24_init_port(ap);
}

926 927
static int sil24_port_start(struct ata_port *ap)
{
Jeff Garzik's avatar
Jeff Garzik committed
928
	struct device *dev = ap->host->dev;
929
	struct sil24_port_priv *pp;
Tejun Heo's avatar
Tejun Heo committed
930
	union sil24_cmd_block *cb;
931
	size_t cb_size = sizeof(*cb) * SIL24_MAX_CMDS;
932
	dma_addr_t cb_dma;
933
	int rc;
934

935
	pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
936
	if (!pp)
937
		return -ENOMEM;
938

939 940
	pp->tf.command = ATA_DRDY;

941
	cb = dmam_alloc_coherent(dev, cb_size, &cb_dma, GFP_KERNEL);
942
	if (!cb)
943
		return -ENOMEM;
944 945
	memset(cb, 0, cb_size);

946 947
	rc = ata_pad_alloc(ap, dev);
	if (rc)
948
		return rc;
949

950 951 952 953 954 955 956 957
	pp->cmd_block = cb;
	pp->cmd_block_dma = cb_dma;

	ap->private_data = pp;

	return 0;
}

958
static void sil24_init_controller(struct ata_host *host)
959
{
960 961
	void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
	void __iomem *port_base = host->iomap[SIL24_PORT_BAR];
962 963 964 965 966 967 968 969 970 971
	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 */
972
	for (i = 0; i < host->n_ports; i++) {
973 974 975 976 977 978 979 980 981 982 983 984 985
		void __iomem *port = port_base + i * PORT_REGS_SIZE;

		/* 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)
986
				dev_printk(KERN_ERR, host->dev,
987 988 989 990
				           "failed to clear port RST\n");
		}

		/* Configure IRQ WoC */
991
		if (host->ports[0]->flags & SIL24_FLAG_PCIX_IRQ_WOC)
992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
			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 */
1008 1009
		writel(PORT_CS_PMP_EN | PORT_CS_PMP_RESUME,
		       port + PORT_CTRL_CLR);
1010 1011 1012 1013 1014 1015
	}

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

1016 1017 1018
static int sil24_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
{
	static int printed_version = 0;
1019 1020 1021 1022
	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;
1023
	int i, rc;
1024
	u32 tmp;
1025 1026

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

1029
	/* acquire resources */
1030
	rc = pcim_enable_device(pdev);
1031 1032 1033
	if (rc)
		return rc;

Tejun Heo's avatar
Tejun Heo committed
1034 1035 1036
	rc = pcim_iomap_regions(pdev,
				(1 << SIL24_HOST_BAR) | (1 << SIL24_PORT_BAR),
				DRV_NAME);
1037
	if (rc)
1038
		return rc;
1039
	iomap = pcim_iomap_table(pdev);
1040

1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
	/* 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;
	}
1051

1052 1053 1054 1055 1056 1057
	/* allocate and fill host */
	host = ata_host_alloc_pinfo(&pdev->dev, ppi,
				    SIL24_FLAG2NPORTS(ppi[0]->flags));
	if (!host)
		return -ENOMEM;
	host->iomap = iomap;
1058

1059 1060
	for (i = 0; i < host->n_ports; i++) {
		void __iomem *port = iomap[SIL24_PORT_BAR] + i * PORT_REGS_SIZE;
1061

1062 1063
		host->ports[i]->ioaddr.cmd_addr = port;
		host->ports[i]->ioaddr.scr_addr = port + PORT_SCONTROL;
1064

1065 1066
		ata_std_ports(&host->ports[i]->ioaddr);
	}
1067

1068
	/* configure and activate the device */
Tejun Heo's avatar
Tejun Heo committed
1069 1070 1071 1072 1073 1074 1075
	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");
1076
				return rc;
Tejun Heo's avatar
Tejun Heo committed
1077 1078 1079 1080 1081 1082 1083
			}
		}
	} else {
		rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
		if (rc) {
			dev_printk(KERN_ERR, &pdev->dev,
				   "32-bit DMA enable failed\n");
1084
			return rc;
Tejun Heo's avatar
Tejun Heo committed
1085 1086 1087 1088 1089
		}
		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");
1090
			return rc;
Tejun Heo's avatar
Tejun Heo committed
1091
		}
1092 1093
	}

1094
	sil24_init_controller(host);
1095 1096

	pci_set_master(pdev);
1097 1098
	return ata_host_activate(host, pdev->irq, sil24_interrupt, IRQF_SHARED,
				 &sil24_sht);
1099 1100
}

1101
#ifdef CONFIG_PM
1102 1103
static int sil24_pci_device_resume(struct pci_dev *pdev)
{
Jeff Garzik's avatar
Jeff Garzik committed
1104
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
Tejun Heo's avatar
Tejun Heo committed
1105
	void __iomem *host_base = host->iomap[SIL24_HOST_BAR];
1106
	int rc;
1107

1108 1109 1110
	rc = ata_pci_device_do_resume(pdev);
	if (rc)
		return rc;
1111 1112

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

1115
	sil24_init_controller(host);
1116

Jeff Garzik's avatar
Jeff Garzik committed
1117
	ata_host_resume(host);
1118 1119 1120

	return 0;
}
1121
#endif
1122

1123 1124
static int __init sil24_init(void)
{
1125
	return pci_register_driver(&sil24_pci_driver);
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
}

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);