sata_nv.c 15.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 *  sata_nv.c - NVIDIA nForce SATA
 *
 *  Copyright 2004 NVIDIA Corp.  All rights reserved.
 *  Copyright 2004 Andrew Chew
 *
7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
L
Linus Torvalds 已提交
21
 *
22 23 24 25 26 27 28 29 30 31
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/DocBook/libata.*
 *
 *  No hardware documentation available outside of NVIDIA.
 *  This driver programs the NVIDIA SATA controller in a similar
 *  fashion as with other PCI IDE BMDMA controllers, with a few
 *  NV-specific details such as register offsets, SATA phy location,
 *  hotplug info, etc.
 *
L
Linus Torvalds 已提交
32 33 34 35 36 37 38 39 40
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
41
#include <linux/device.h>
L
Linus Torvalds 已提交
42 43 44 45
#include <scsi/scsi_host.h>
#include <linux/libata.h>

#define DRV_NAME			"sata_nv"
J
Jeff Garzik 已提交
46
#define DRV_VERSION			"2.0"
L
Linus Torvalds 已提交
47

48 49 50 51 52 53 54
enum {
	NV_PORTS			= 2,
	NV_PIO_MASK			= 0x1f,
	NV_MWDMA_MASK			= 0x07,
	NV_UDMA_MASK			= 0x7f,
	NV_PORT0_SCR_REG_OFFSET		= 0x00,
	NV_PORT1_SCR_REG_OFFSET		= 0x40,
L
Linus Torvalds 已提交
55

T
Tejun Heo 已提交
56
	/* INT_STATUS/ENABLE */
57 58
	NV_INT_STATUS			= 0x10,
	NV_INT_ENABLE			= 0x11,
T
Tejun Heo 已提交
59
	NV_INT_STATUS_CK804		= 0x440,
60
	NV_INT_ENABLE_CK804		= 0x441,
L
Linus Torvalds 已提交
61

T
Tejun Heo 已提交
62 63 64 65 66 67 68 69
	/* INT_STATUS/ENABLE bits */
	NV_INT_DEV			= 0x01,
	NV_INT_PM			= 0x02,
	NV_INT_ADDED			= 0x04,
	NV_INT_REMOVED			= 0x08,

	NV_INT_PORT_SHIFT		= 4,	/* each port occupies 4 bits */

T
Tejun Heo 已提交
70
	NV_INT_ALL			= 0x0f,
T
Tejun Heo 已提交
71 72
	NV_INT_MASK			= NV_INT_DEV |
					  NV_INT_ADDED | NV_INT_REMOVED,
T
Tejun Heo 已提交
73

T
Tejun Heo 已提交
74
	/* INT_CONFIG */
75 76
	NV_INT_CONFIG			= 0x12,
	NV_INT_CONFIG_METHD		= 0x01, // 0 = INT, 1 = SMI
L
Linus Torvalds 已提交
77

78 79 80 81
	// For PCI config register 20
	NV_MCP_SATA_CFG_20		= 0x50,
	NV_MCP_SATA_CFG_20_SATA_SPACE_EN = 0x04,
};
L
Linus Torvalds 已提交
82 83

static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
J
Jeff Garzik 已提交
84
static void nv_ck804_host_stop(struct ata_host *host);
T
Tejun Heo 已提交
85 86 87 88 89 90
static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance,
					struct pt_regs *regs);
static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance,
				    struct pt_regs *regs);
static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance,
				      struct pt_regs *regs);
L
Linus Torvalds 已提交
91 92 93
static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);

T
Tejun Heo 已提交
94 95 96 97 98 99
static void nv_nf2_freeze(struct ata_port *ap);
static void nv_nf2_thaw(struct ata_port *ap);
static void nv_ck804_freeze(struct ata_port *ap);
static void nv_ck804_thaw(struct ata_port *ap);
static void nv_error_handler(struct ata_port *ap);

L
Linus Torvalds 已提交
100 101 102 103
enum nv_host_type
{
	GENERIC,
	NFORCE2,
T
Tejun Heo 已提交
104
	NFORCE3 = NFORCE2,	/* NF2 == NF3 as far as sata_nv is concerned */
105
	CK804
L
Linus Torvalds 已提交
106 107
};

108
static const struct pci_device_id nv_pci_tbl[] = {
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA), NFORCE2 },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA), NFORCE3 },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2), NFORCE3 },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA), CK804 },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2), CK804 },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA), CK804 },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2), CK804 },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA), GENERIC },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2), GENERIC },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA), GENERIC },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2), GENERIC },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA), GENERIC },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2), GENERIC },
	{ PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3), GENERIC },
	{ PCI_VDEVICE(NVIDIA, 0x045c), GENERIC },
	{ PCI_VDEVICE(NVIDIA, 0x045d), GENERIC },
	{ PCI_VDEVICE(NVIDIA, 0x045e), GENERIC },
	{ PCI_VDEVICE(NVIDIA, 0x045f), GENERIC },
L
Linus Torvalds 已提交
127 128 129
	{ PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
		PCI_ANY_ID, PCI_ANY_ID,
		PCI_CLASS_STORAGE_IDE<<8, 0xffff00, GENERIC },
130 131 132
	{ PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
		PCI_ANY_ID, PCI_ANY_ID,
		PCI_CLASS_STORAGE_RAID<<8, 0xffff00, GENERIC },
133 134

	{ } /* terminate list */
L
Linus Torvalds 已提交
135 136 137 138 139 140 141 142 143
};

static struct pci_driver nv_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= nv_pci_tbl,
	.probe			= nv_init_one,
	.remove			= ata_pci_remove_one,
};

144
static struct scsi_host_template nv_sht = {
L
Linus Torvalds 已提交
145 146 147 148 149 150 151 152 153 154 155 156 157
	.module			= THIS_MODULE,
	.name			= DRV_NAME,
	.ioctl			= ata_scsi_ioctl,
	.queuecommand		= ata_scsi_queuecmd,
	.can_queue		= ATA_DEF_QUEUE,
	.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,
T
Tejun Heo 已提交
158
	.slave_destroy		= ata_scsi_slave_destroy,
L
Linus Torvalds 已提交
159 160 161
	.bios_param		= ata_std_bios_param,
};

T
Tejun Heo 已提交
162
static const struct ata_port_operations nv_generic_ops = {
L
Linus Torvalds 已提交
163 164 165 166 167 168 169 170 171 172 173 174
	.port_disable		= ata_port_disable,
	.tf_load		= ata_tf_load,
	.tf_read		= ata_tf_read,
	.exec_command		= ata_exec_command,
	.check_status		= ata_check_status,
	.dev_select		= ata_std_dev_select,
	.bmdma_setup		= ata_bmdma_setup,
	.bmdma_start		= ata_bmdma_start,
	.bmdma_stop		= ata_bmdma_stop,
	.bmdma_status		= ata_bmdma_status,
	.qc_prep		= ata_qc_prep,
	.qc_issue		= ata_qc_issue_prot,
T
Tejun Heo 已提交
175 176 177 178
	.freeze			= ata_bmdma_freeze,
	.thaw			= ata_bmdma_thaw,
	.error_handler		= nv_error_handler,
	.post_internal_cmd	= ata_bmdma_post_internal_cmd,
179
	.data_xfer		= ata_pio_data_xfer,
T
Tejun Heo 已提交
180
	.irq_handler		= nv_generic_interrupt,
L
Linus Torvalds 已提交
181 182 183 184 185
	.irq_clear		= ata_bmdma_irq_clear,
	.scr_read		= nv_scr_read,
	.scr_write		= nv_scr_write,
	.port_start		= ata_port_start,
	.port_stop		= ata_port_stop,
186
	.host_stop		= ata_pci_host_stop,
L
Linus Torvalds 已提交
187 188
};

T
Tejun Heo 已提交
189 190 191 192 193 194 195 196 197 198 199 200 201
static const struct ata_port_operations nv_nf2_ops = {
	.port_disable		= ata_port_disable,
	.tf_load		= ata_tf_load,
	.tf_read		= ata_tf_read,
	.exec_command		= ata_exec_command,
	.check_status		= ata_check_status,
	.dev_select		= ata_std_dev_select,
	.bmdma_setup		= ata_bmdma_setup,
	.bmdma_start		= ata_bmdma_start,
	.bmdma_stop		= ata_bmdma_stop,
	.bmdma_status		= ata_bmdma_status,
	.qc_prep		= ata_qc_prep,
	.qc_issue		= ata_qc_issue_prot,
T
Tejun Heo 已提交
202 203 204 205
	.freeze			= nv_nf2_freeze,
	.thaw			= nv_nf2_thaw,
	.error_handler		= nv_error_handler,
	.post_internal_cmd	= ata_bmdma_post_internal_cmd,
T
Tejun Heo 已提交
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
	.data_xfer		= ata_pio_data_xfer,
	.irq_handler		= nv_nf2_interrupt,
	.irq_clear		= ata_bmdma_irq_clear,
	.scr_read		= nv_scr_read,
	.scr_write		= nv_scr_write,
	.port_start		= ata_port_start,
	.port_stop		= ata_port_stop,
	.host_stop		= ata_pci_host_stop,
};

static const struct ata_port_operations nv_ck804_ops = {
	.port_disable		= ata_port_disable,
	.tf_load		= ata_tf_load,
	.tf_read		= ata_tf_read,
	.exec_command		= ata_exec_command,
	.check_status		= ata_check_status,
	.dev_select		= ata_std_dev_select,
	.bmdma_setup		= ata_bmdma_setup,
	.bmdma_start		= ata_bmdma_start,
	.bmdma_stop		= ata_bmdma_stop,
	.bmdma_status		= ata_bmdma_status,
	.qc_prep		= ata_qc_prep,
	.qc_issue		= ata_qc_issue_prot,
T
Tejun Heo 已提交
229 230 231 232
	.freeze			= nv_ck804_freeze,
	.thaw			= nv_ck804_thaw,
	.error_handler		= nv_error_handler,
	.post_internal_cmd	= ata_bmdma_post_internal_cmd,
T
Tejun Heo 已提交
233 234 235 236 237 238 239 240 241 242 243 244 245 246
	.data_xfer		= ata_pio_data_xfer,
	.irq_handler		= nv_ck804_interrupt,
	.irq_clear		= ata_bmdma_irq_clear,
	.scr_read		= nv_scr_read,
	.scr_write		= nv_scr_write,
	.port_start		= ata_port_start,
	.port_stop		= ata_port_stop,
	.host_stop		= nv_ck804_host_stop,
};

static struct ata_port_info nv_port_info[] = {
	/* generic */
	{
		.sht		= &nv_sht,
J
Jeff Garzik 已提交
247
		.flags		= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
T
Tejun Heo 已提交
248 249 250 251 252 253 254 255
		.pio_mask	= NV_PIO_MASK,
		.mwdma_mask	= NV_MWDMA_MASK,
		.udma_mask	= NV_UDMA_MASK,
		.port_ops	= &nv_generic_ops,
	},
	/* nforce2/3 */
	{
		.sht		= &nv_sht,
J
Jeff Garzik 已提交
256
		.flags		= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
T
Tejun Heo 已提交
257 258 259 260 261 262 263 264
		.pio_mask	= NV_PIO_MASK,
		.mwdma_mask	= NV_MWDMA_MASK,
		.udma_mask	= NV_UDMA_MASK,
		.port_ops	= &nv_nf2_ops,
	},
	/* ck804 */
	{
		.sht		= &nv_sht,
J
Jeff Garzik 已提交
265
		.flags		= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
T
Tejun Heo 已提交
266 267 268 269 270
		.pio_mask	= NV_PIO_MASK,
		.mwdma_mask	= NV_MWDMA_MASK,
		.udma_mask	= NV_UDMA_MASK,
		.port_ops	= &nv_ck804_ops,
	},
L
Linus Torvalds 已提交
271 272 273 274 275 276 277 278
};

MODULE_AUTHOR("NVIDIA");
MODULE_DESCRIPTION("low-level driver for NVIDIA nForce SATA controller");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, nv_pci_tbl);
MODULE_VERSION(DRV_VERSION);

T
Tejun Heo 已提交
279 280
static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance,
					struct pt_regs *regs)
L
Linus Torvalds 已提交
281
{
J
Jeff Garzik 已提交
282
	struct ata_host *host = dev_instance;
L
Linus Torvalds 已提交
283 284 285 286
	unsigned int i;
	unsigned int handled = 0;
	unsigned long flags;

J
Jeff Garzik 已提交
287
	spin_lock_irqsave(&host->lock, flags);
L
Linus Torvalds 已提交
288

J
Jeff Garzik 已提交
289
	for (i = 0; i < host->n_ports; i++) {
L
Linus Torvalds 已提交
290 291
		struct ata_port *ap;

J
Jeff Garzik 已提交
292
		ap = host->ports[i];
293
		if (ap &&
J
Jeff Garzik 已提交
294
		    !(ap->flags & ATA_FLAG_DISABLED)) {
L
Linus Torvalds 已提交
295 296 297
			struct ata_queued_cmd *qc;

			qc = ata_qc_from_tag(ap, ap->active_tag);
298
			if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
L
Linus Torvalds 已提交
299
				handled += ata_host_intr(ap, qc);
300 301 302 303
			else
				// No request pending?  Clear interrupt status
				// anyway, in case there's one pending.
				ap->ops->check_status(ap);
L
Linus Torvalds 已提交
304 305 306 307
		}

	}

J
Jeff Garzik 已提交
308
	spin_unlock_irqrestore(&host->lock, flags);
L
Linus Torvalds 已提交
309 310 311 312

	return IRQ_RETVAL(handled);
}

T
Tejun Heo 已提交
313 314 315 316 317
static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
{
	struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->active_tag);
	int handled;

T
Tejun Heo 已提交
318 319 320 321 322 323
	/* freeze if hotplugged */
	if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
		ata_port_freeze(ap);
		return 1;
	}

T
Tejun Heo 已提交
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
	/* bail out if not our interrupt */
	if (!(irq_stat & NV_INT_DEV))
		return 0;

	/* DEV interrupt w/ no active qc? */
	if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) {
		ata_check_status(ap);
		return 1;
	}

	/* handle interrupt */
	handled = ata_host_intr(ap, qc);
	if (unlikely(!handled)) {
		/* spurious, clear it */
		ata_check_status(ap);
	}

	return 1;
}

J
Jeff Garzik 已提交
344
static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
T
Tejun Heo 已提交
345 346 347
{
	int i, handled = 0;

J
Jeff Garzik 已提交
348 349
	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];
T
Tejun Heo 已提交
350 351 352 353 354 355 356 357 358 359 360 361 362

		if (ap && !(ap->flags & ATA_FLAG_DISABLED))
			handled += nv_host_intr(ap, irq_stat);

		irq_stat >>= NV_INT_PORT_SHIFT;
	}

	return IRQ_RETVAL(handled);
}

static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance,
				    struct pt_regs *regs)
{
J
Jeff Garzik 已提交
363
	struct ata_host *host = dev_instance;
T
Tejun Heo 已提交
364 365 366
	u8 irq_stat;
	irqreturn_t ret;

J
Jeff Garzik 已提交
367 368 369 370
	spin_lock(&host->lock);
	irq_stat = inb(host->ports[0]->ioaddr.scr_addr + NV_INT_STATUS);
	ret = nv_do_interrupt(host, irq_stat);
	spin_unlock(&host->lock);
T
Tejun Heo 已提交
371 372 373 374 375 376 377

	return ret;
}

static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance,
				      struct pt_regs *regs)
{
J
Jeff Garzik 已提交
378
	struct ata_host *host = dev_instance;
T
Tejun Heo 已提交
379 380 381
	u8 irq_stat;
	irqreturn_t ret;

J
Jeff Garzik 已提交
382 383 384 385
	spin_lock(&host->lock);
	irq_stat = readb(host->mmio_base + NV_INT_STATUS_CK804);
	ret = nv_do_interrupt(host, irq_stat);
	spin_unlock(&host->lock);
T
Tejun Heo 已提交
386 387 388 389

	return ret;
}

L
Linus Torvalds 已提交
390 391 392 393 394
static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg)
{
	if (sc_reg > SCR_CONTROL)
		return 0xffffffffU;

395
	return ioread32((void __iomem *)ap->ioaddr.scr_addr + (sc_reg * 4));
L
Linus Torvalds 已提交
396 397 398 399 400 401 402
}

static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
{
	if (sc_reg > SCR_CONTROL)
		return;

403
	iowrite32(val, (void __iomem *)ap->ioaddr.scr_addr + (sc_reg * 4));
L
Linus Torvalds 已提交
404 405
}

T
Tejun Heo 已提交
406 407
static void nv_nf2_freeze(struct ata_port *ap)
{
J
Jeff Garzik 已提交
408
	unsigned long scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
T
Tejun Heo 已提交
409 410 411 412 413 414 415 416 417 418
	int shift = ap->port_no * NV_INT_PORT_SHIFT;
	u8 mask;

	mask = inb(scr_addr + NV_INT_ENABLE);
	mask &= ~(NV_INT_ALL << shift);
	outb(mask, scr_addr + NV_INT_ENABLE);
}

static void nv_nf2_thaw(struct ata_port *ap)
{
J
Jeff Garzik 已提交
419
	unsigned long scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
T
Tejun Heo 已提交
420 421 422 423 424 425 426 427 428 429 430 431
	int shift = ap->port_no * NV_INT_PORT_SHIFT;
	u8 mask;

	outb(NV_INT_ALL << shift, scr_addr + NV_INT_STATUS);

	mask = inb(scr_addr + NV_INT_ENABLE);
	mask |= (NV_INT_MASK << shift);
	outb(mask, scr_addr + NV_INT_ENABLE);
}

static void nv_ck804_freeze(struct ata_port *ap)
{
J
Jeff Garzik 已提交
432
	void __iomem *mmio_base = ap->host->mmio_base;
T
Tejun Heo 已提交
433 434 435 436 437 438 439 440 441 442
	int shift = ap->port_no * NV_INT_PORT_SHIFT;
	u8 mask;

	mask = readb(mmio_base + NV_INT_ENABLE_CK804);
	mask &= ~(NV_INT_ALL << shift);
	writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
}

static void nv_ck804_thaw(struct ata_port *ap)
{
J
Jeff Garzik 已提交
443
	void __iomem *mmio_base = ap->host->mmio_base;
T
Tejun Heo 已提交
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
	int shift = ap->port_no * NV_INT_PORT_SHIFT;
	u8 mask;

	writeb(NV_INT_ALL << shift, mmio_base + NV_INT_STATUS_CK804);

	mask = readb(mmio_base + NV_INT_ENABLE_CK804);
	mask |= (NV_INT_MASK << shift);
	writeb(mask, mmio_base + NV_INT_ENABLE_CK804);
}

static int nv_hardreset(struct ata_port *ap, unsigned int *class)
{
	unsigned int dummy;

	/* SATA hardreset fails to retrieve proper device signature on
	 * some controllers.  Don't classify on hardreset.  For more
	 * info, see http://bugme.osdl.org/show_bug.cgi?id=3352
	 */
	return sata_std_hardreset(ap, &dummy);
}

static void nv_error_handler(struct ata_port *ap)
{
	ata_bmdma_drive_eh(ap, ata_std_prereset, ata_std_softreset,
			   nv_hardreset, ata_std_postreset);
}

L
Linus Torvalds 已提交
471 472 473
static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
	static int printed_version = 0;
474
	struct ata_port_info *ppi[2];
L
Linus Torvalds 已提交
475 476 477 478
	struct ata_probe_ent *probe_ent;
	int pci_dev_busy = 0;
	int rc;
	u32 bar;
479
	unsigned long base;
L
Linus Torvalds 已提交
480 481 482 483 484 485 486 487 488

        // Make sure this is a SATA controller by counting the number of bars
        // (NVIDIA SATA controllers will always have six bars).  Otherwise,
        // it's an IDE controller and we ignore it.
	for (bar=0; bar<6; bar++)
		if (pci_resource_start(pdev, bar) == 0)
			return -ENODEV;

	if (!printed_version++)
489
		dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
L
Linus Torvalds 已提交
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509

	rc = pci_enable_device(pdev);
	if (rc)
		goto err_out;

	rc = pci_request_regions(pdev, DRV_NAME);
	if (rc) {
		pci_dev_busy = 1;
		goto err_out_disable;
	}

	rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
	if (rc)
		goto err_out_regions;
	rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
	if (rc)
		goto err_out_regions;

	rc = -ENOMEM;

510 511
	ppi[0] = ppi[1] = &nv_port_info[ent->driver_data];
	probe_ent = ata_pci_init_native_mode(pdev, ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
L
Linus Torvalds 已提交
512 513 514
	if (!probe_ent)
		goto err_out_regions;

515 516 517
	probe_ent->mmio_base = pci_iomap(pdev, 5, 0);
	if (!probe_ent->mmio_base) {
		rc = -EIO;
518
		goto err_out_free_ent;
519
	}
L
Linus Torvalds 已提交
520

521
	base = (unsigned long)probe_ent->mmio_base;
L
Linus Torvalds 已提交
522

523 524
	probe_ent->port[0].scr_addr = base + NV_PORT0_SCR_REG_OFFSET;
	probe_ent->port[1].scr_addr = base + NV_PORT1_SCR_REG_OFFSET;
L
Linus Torvalds 已提交
525

T
Tejun Heo 已提交
526 527 528 529 530 531 532 533 534
	/* enable SATA space for CK804 */
	if (ent->driver_data == CK804) {
		u8 regval;

		pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
		regval |= NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
		pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);
	}

L
Linus Torvalds 已提交
535 536 537 538 539 540 541 542 543 544 545
	pci_set_master(pdev);

	rc = ata_device_add(probe_ent);
	if (rc != NV_PORTS)
		goto err_out_iounmap;

	kfree(probe_ent);

	return 0;

err_out_iounmap:
546
	pci_iounmap(pdev, probe_ent->mmio_base);
L
Linus Torvalds 已提交
547 548 549 550 551 552 553 554 555 556 557
err_out_free_ent:
	kfree(probe_ent);
err_out_regions:
	pci_release_regions(pdev);
err_out_disable:
	if (!pci_dev_busy)
		pci_disable_device(pdev);
err_out:
	return rc;
}

J
Jeff Garzik 已提交
558
static void nv_ck804_host_stop(struct ata_host *host)
T
Tejun Heo 已提交
559
{
J
Jeff Garzik 已提交
560
	struct pci_dev *pdev = to_pci_dev(host->dev);
T
Tejun Heo 已提交
561 562 563 564 565 566 567
	u8 regval;

	/* disable SATA space for CK804 */
	pci_read_config_byte(pdev, NV_MCP_SATA_CFG_20, &regval);
	regval &= ~NV_MCP_SATA_CFG_20_SATA_SPACE_EN;
	pci_write_config_byte(pdev, NV_MCP_SATA_CFG_20, regval);

J
Jeff Garzik 已提交
568
	ata_pci_host_stop(host);
T
Tejun Heo 已提交
569 570
}

L
Linus Torvalds 已提交
571 572
static int __init nv_init(void)
{
573
	return pci_register_driver(&nv_pci_driver);
L
Linus Torvalds 已提交
574 575 576 577 578 579 580 581 582
}

static void __exit nv_exit(void)
{
	pci_unregister_driver(&nv_pci_driver);
}

module_init(nv_init);
module_exit(nv_exit);