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 },
L
Linus Torvalds 已提交
133 134 135 136 137 138 139 140 141 142
	{ 0, } /* terminate list */
};

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

143
static struct scsi_host_template nv_sht = {
L
Linus Torvalds 已提交
144 145 146 147 148 149 150 151 152 153 154 155 156
	.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 已提交
157
	.slave_destroy		= ata_scsi_slave_destroy,
L
Linus Torvalds 已提交
158 159 160
	.bios_param		= ata_std_bios_param,
};

T
Tejun Heo 已提交
161
static const struct ata_port_operations nv_generic_ops = {
L
Linus Torvalds 已提交
162 163 164 165 166 167 168 169 170 171 172 173
	.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 已提交
174 175 176 177
	.freeze			= ata_bmdma_freeze,
	.thaw			= ata_bmdma_thaw,
	.error_handler		= nv_error_handler,
	.post_internal_cmd	= ata_bmdma_post_internal_cmd,
178
	.data_xfer		= ata_pio_data_xfer,
T
Tejun Heo 已提交
179
	.irq_handler		= nv_generic_interrupt,
L
Linus Torvalds 已提交
180 181 182 183 184
	.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,
185
	.host_stop		= ata_pci_host_stop,
L
Linus Torvalds 已提交
186 187
};

T
Tejun Heo 已提交
188 189 190 191 192 193 194 195 196 197 198 199 200
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 已提交
201 202 203 204
	.freeze			= nv_nf2_freeze,
	.thaw			= nv_nf2_thaw,
	.error_handler		= nv_error_handler,
	.post_internal_cmd	= ata_bmdma_post_internal_cmd,
T
Tejun Heo 已提交
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
	.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 已提交
228 229 230 231
	.freeze			= nv_ck804_freeze,
	.thaw			= nv_ck804_thaw,
	.error_handler		= nv_error_handler,
	.post_internal_cmd	= ata_bmdma_post_internal_cmd,
T
Tejun Heo 已提交
232 233 234 235 236 237 238 239 240 241 242 243 244 245
	.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 已提交
246
		.flags		= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
T
Tejun Heo 已提交
247 248 249 250 251 252 253 254
		.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 已提交
255
		.flags		= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
T
Tejun Heo 已提交
256 257 258 259 260 261 262 263
		.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 已提交
264
		.flags		= ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY,
T
Tejun Heo 已提交
265 266 267 268 269
		.pio_mask	= NV_PIO_MASK,
		.mwdma_mask	= NV_MWDMA_MASK,
		.udma_mask	= NV_UDMA_MASK,
		.port_ops	= &nv_ck804_ops,
	},
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277
};

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 已提交
278 279
static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance,
					struct pt_regs *regs)
L
Linus Torvalds 已提交
280
{
J
Jeff Garzik 已提交
281
	struct ata_host *host = dev_instance;
L
Linus Torvalds 已提交
282 283 284 285
	unsigned int i;
	unsigned int handled = 0;
	unsigned long flags;

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

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

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

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

	}

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

	return IRQ_RETVAL(handled);
}

T
Tejun Heo 已提交
312 313 314 315 316
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 已提交
317 318 319 320 321 322
	/* freeze if hotplugged */
	if (unlikely(irq_stat & (NV_INT_ADDED | NV_INT_REMOVED))) {
		ata_port_freeze(ap);
		return 1;
	}

T
Tejun Heo 已提交
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
	/* 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 已提交
343
static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
T
Tejun Heo 已提交
344 345 346
{
	int i, handled = 0;

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

		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 已提交
362
	struct ata_host *host = dev_instance;
T
Tejun Heo 已提交
363 364 365
	u8 irq_stat;
	irqreturn_t ret;

J
Jeff Garzik 已提交
366 367 368 369
	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 已提交
370 371 372 373 374 375 376

	return ret;
}

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

J
Jeff Garzik 已提交
381 382 383 384
	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 已提交
385 386 387 388

	return ret;
}

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

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

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

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

T
Tejun Heo 已提交
405 406
static void nv_nf2_freeze(struct ata_port *ap)
{
J
Jeff Garzik 已提交
407
	unsigned long scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
T
Tejun Heo 已提交
408 409 410 411 412 413 414 415 416 417
	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 已提交
418
	unsigned long scr_addr = ap->host->ports[0]->ioaddr.scr_addr;
T
Tejun Heo 已提交
419 420 421 422 423 424 425 426 427 428 429 430
	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 已提交
431
	void __iomem *mmio_base = ap->host->mmio_base;
T
Tejun Heo 已提交
432 433 434 435 436 437 438 439 440 441
	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 已提交
442
	void __iomem *mmio_base = ap->host->mmio_base;
T
Tejun Heo 已提交
443 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
	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 已提交
470 471 472
static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
	static int printed_version = 0;
473
	struct ata_port_info *ppi[2];
L
Linus Torvalds 已提交
474 475 476 477
	struct ata_probe_ent *probe_ent;
	int pci_dev_busy = 0;
	int rc;
	u32 bar;
478
	unsigned long base;
L
Linus Torvalds 已提交
479 480 481 482 483 484 485 486 487

        // 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++)
488
		dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
L
Linus Torvalds 已提交
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508

	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;

509 510
	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 已提交
511 512 513
	if (!probe_ent)
		goto err_out_regions;

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

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

522 523
	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 已提交
524

T
Tejun Heo 已提交
525 526 527 528 529 530 531 532 533
	/* 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 已提交
534 535 536 537 538 539 540 541 542 543 544
	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:
545
	pci_iounmap(pdev, probe_ent->mmio_base);
L
Linus Torvalds 已提交
546 547 548 549 550 551 552 553 554 555 556
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 已提交
557
static void nv_ck804_host_stop(struct ata_host *host)
T
Tejun Heo 已提交
558
{
J
Jeff Garzik 已提交
559
	struct pci_dev *pdev = to_pci_dev(host->dev);
T
Tejun Heo 已提交
560 561 562 563 564 565 566
	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 已提交
567
	ata_pci_host_stop(host);
T
Tejun Heo 已提交
568 569
}

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

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

module_init(nv_init);
module_exit(nv_exit);