sata_via.c 17.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2 3
 *  sata_via.c - VIA Serial ATA controllers
 *
4
 *  Maintained by:  Tejun Heo <tj@kernel.org>
5
 * 		   Please ALWAYS copy linux-ide@vger.kernel.org
6
 *		   on emails.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 *
 *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
 *  Copyright 2003-2004 Jeff Garzik
 *
 *
 *  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.
 *
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/DocBook/libata.*
 *
 *  Hardware documentation available under NDA.
 *
 *
 *
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36 37 38 39 40 41
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
42
#include <linux/device.h>
43 44
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
Linus Torvalds's avatar
Linus Torvalds committed
45 46 47 48
#include <scsi/scsi_host.h>
#include <linux/libata.h>

#define DRV_NAME	"sata_via"
49
#define DRV_VERSION	"2.6"
Linus Torvalds's avatar
Linus Torvalds committed
50

51 52 53 54
/*
 * vt8251 is different from other sata controllers of VIA.  It has two
 * channels, each channel has both Master and Slave slot.
 */
Linus Torvalds's avatar
Linus Torvalds committed
55 56 57
enum board_ids_enum {
	vt6420,
	vt6421,
58
	vt8251,
Linus Torvalds's avatar
Linus Torvalds committed
59 60 61 62 63 64
};

enum {
	SATA_CHAN_ENAB		= 0x40, /* SATA channel enable */
	SATA_INT_GATE		= 0x41, /* SATA interrupt gating */
	SATA_NATIVE_MODE	= 0x42, /* Native mode enable */
Alan's avatar
Alan committed
65 66
	PATA_UDMA_TIMING	= 0xB3, /* PATA timing for DMA/ cable detect */
	PATA_PIO_TIMING		= 0xAB, /* PATA timing register */
67

Linus Torvalds's avatar
Linus Torvalds committed
68 69 70 71 72 73 74 75 76
	PORT0			= (1 << 1),
	PORT1			= (1 << 0),
	ALL_PORTS		= PORT0 | PORT1,

	NATIVE_MODE_ALL		= (1 << 7) | (1 << 6) | (1 << 5) | (1 << 4),

	SATA_EXT_PHY		= (1 << 6), /* 0==use PATA, 1==ext phy */
};

77
static int svia_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
78 79
static int svia_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
static int svia_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
80 81
static int vt8251_scr_read(struct ata_link *link, unsigned int scr, u32 *val);
static int vt8251_scr_write(struct ata_link *link, unsigned int scr, u32 val);
82
static void svia_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
83
static void svia_noop_freeze(struct ata_port *ap);
84
static int vt6420_prereset(struct ata_link *link, unsigned long deadline);
85
static void vt6420_bmdma_start(struct ata_queued_cmd *qc);
86
static int vt6421_pata_cable_detect(struct ata_port *ap);
Alan's avatar
Alan committed
87 88
static void vt6421_set_pio_mode(struct ata_port *ap, struct ata_device *adev);
static void vt6421_set_dma_mode(struct ata_port *ap, struct ata_device *adev);
Linus Torvalds's avatar
Linus Torvalds committed
89

90
static const struct pci_device_id svia_pci_tbl[] = {
91
	{ PCI_VDEVICE(VIA, 0x5337), vt6420 },
92 93 94
	{ PCI_VDEVICE(VIA, 0x0591), vt6420 }, /* 2 sata chnls (Master) */
	{ PCI_VDEVICE(VIA, 0x3149), vt6420 }, /* 2 sata chnls (Master) */
	{ PCI_VDEVICE(VIA, 0x3249), vt6421 }, /* 2 sata chnls, 1 pata chnl */
95 96
	{ PCI_VDEVICE(VIA, 0x5372), vt6420 },
	{ PCI_VDEVICE(VIA, 0x7372), vt6420 },
97
	{ PCI_VDEVICE(VIA, 0x5287), vt8251 }, /* 2 sata chnls (Master/Slave) */
98
	{ PCI_VDEVICE(VIA, 0x9000), vt8251 },
Linus Torvalds's avatar
Linus Torvalds committed
99 100 101 102 103 104 105 106

	{ }	/* terminate list */
};

static struct pci_driver svia_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= svia_pci_tbl,
	.probe			= svia_init_one,
107 108 109 110
#ifdef CONFIG_PM
	.suspend		= ata_pci_device_suspend,
	.resume			= ata_pci_device_resume,
#endif
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113
	.remove			= ata_pci_remove_one,
};

114
static struct scsi_host_template svia_sht = {
115
	ATA_BMDMA_SHT(DRV_NAME),
Linus Torvalds's avatar
Linus Torvalds committed
116 117
};

118
static struct ata_port_operations svia_base_ops = {
119
	.inherits		= &ata_bmdma_port_ops,
120 121 122 123 124
	.sff_tf_load		= svia_tf_load,
};

static struct ata_port_operations vt6420_sata_ops = {
	.inherits		= &svia_base_ops,
125
	.freeze			= svia_noop_freeze,
126
	.prereset		= vt6420_prereset,
127
	.bmdma_start		= vt6420_bmdma_start,
128 129
};

130
static struct ata_port_operations vt6421_pata_ops = {
131
	.inherits		= &svia_base_ops,
132
	.cable_detect		= vt6421_pata_cable_detect,
Alan's avatar
Alan committed
133 134 135 136
	.set_piomode		= vt6421_set_pio_mode,
	.set_dmamode		= vt6421_set_dma_mode,
};

137
static struct ata_port_operations vt6421_sata_ops = {
138
	.inherits		= &svia_base_ops,
Linus Torvalds's avatar
Linus Torvalds committed
139 140 141 142
	.scr_read		= svia_scr_read,
	.scr_write		= svia_scr_write,
};

143 144 145 146 147 148 149
static struct ata_port_operations vt8251_ops = {
	.inherits		= &svia_base_ops,
	.hardreset		= sata_std_hardreset,
	.scr_read		= vt8251_scr_read,
	.scr_write		= vt8251_scr_write,
};

150
static const struct ata_port_info vt6420_port_info = {
151
	.flags		= ATA_FLAG_SATA,
152 153
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
154
	.udma_mask	= ATA_UDMA6,
155
	.port_ops	= &vt6420_sata_ops,
Linus Torvalds's avatar
Linus Torvalds committed
156 157
};

158
static struct ata_port_info vt6421_sport_info = {
159
	.flags		= ATA_FLAG_SATA,
160 161
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
162
	.udma_mask	= ATA_UDMA6,
163 164 165 166
	.port_ops	= &vt6421_sata_ops,
};

static struct ata_port_info vt6421_pport_info = {
167
	.flags		= ATA_FLAG_SLAVE_POSS,
168 169
	.pio_mask	= ATA_PIO4,
	/* No MWDMA */
170
	.udma_mask	= ATA_UDMA6,
171 172 173
	.port_ops	= &vt6421_pata_ops,
};

174
static struct ata_port_info vt8251_port_info = {
175
	.flags		= ATA_FLAG_SATA | ATA_FLAG_SLAVE_POSS,
176 177
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
178 179 180 181
	.udma_mask	= ATA_UDMA6,
	.port_ops	= &vt8251_ops,
};

Linus Torvalds's avatar
Linus Torvalds committed
182 183 184 185 186 187
MODULE_AUTHOR("Jeff Garzik");
MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
MODULE_VERSION(DRV_VERSION);

188
static int svia_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
Linus Torvalds's avatar
Linus Torvalds committed
189 190
{
	if (sc_reg > SCR_CONTROL)
191
		return -EINVAL;
192
	*val = ioread32(link->ap->ioaddr.scr_addr + (4 * sc_reg));
193
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
194 195
}

196
static int svia_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
Linus Torvalds's avatar
Linus Torvalds committed
197 198
{
	if (sc_reg > SCR_CONTROL)
199
		return -EINVAL;
200
	iowrite32(val, link->ap->ioaddr.scr_addr + (4 * sc_reg));
201
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
202 203
}

204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
static int vt8251_scr_read(struct ata_link *link, unsigned int scr, u32 *val)
{
	static const u8 ipm_tbl[] = { 1, 2, 6, 0 };
	struct pci_dev *pdev = to_pci_dev(link->ap->host->dev);
	int slot = 2 * link->ap->port_no + link->pmp;
	u32 v = 0;
	u8 raw;

	switch (scr) {
	case SCR_STATUS:
		pci_read_config_byte(pdev, 0xA0 + slot, &raw);

		/* read the DET field, bit0 and 1 of the config byte */
		v |= raw & 0x03;

		/* read the SPD field, bit4 of the configure byte */
		if (raw & (1 << 4))
			v |= 0x02 << 4;
		else
			v |= 0x01 << 4;

		/* read the IPM field, bit2 and 3 of the config byte */
		v |= ipm_tbl[(raw >> 2) & 0x3];
		break;

	case SCR_ERROR:
		/* devices other than 5287 uses 0xA8 as base */
		WARN_ON(pdev->device != 0x5287);
		pci_read_config_dword(pdev, 0xB0 + slot * 4, &v);
		break;

	case SCR_CONTROL:
		pci_read_config_byte(pdev, 0xA4 + slot, &raw);

		/* read the DET field, bit0 and bit1 */
		v |= ((raw & 0x02) << 1) | (raw & 0x01);

		/* read the IPM field, bit2 and bit3 */
		v |= ((raw >> 2) & 0x03) << 8;
		break;

	default:
		return -EINVAL;
	}

	*val = v;
	return 0;
}

static int vt8251_scr_write(struct ata_link *link, unsigned int scr, u32 val)
{
	struct pci_dev *pdev = to_pci_dev(link->ap->host->dev);
	int slot = 2 * link->ap->port_no + link->pmp;
	u32 v = 0;

	switch (scr) {
	case SCR_ERROR:
		/* devices other than 5287 uses 0xA8 as base */
		WARN_ON(pdev->device != 0x5287);
		pci_write_config_dword(pdev, 0xB0 + slot * 4, val);
		return 0;

	case SCR_CONTROL:
		/* set the DET field */
		v |= ((val & 0x4) >> 1) | (val & 0x1);

		/* set the IPM field */
		v |= ((val >> 8) & 0x3) << 2;

		pci_write_config_byte(pdev, 0xA4 + slot, v);
		return 0;

	default:
		return -EINVAL;
	}
}

281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
/**
 *	svia_tf_load - send taskfile registers to host controller
 *	@ap: Port to which output is sent
 *	@tf: ATA taskfile register set
 *
 *	Outputs ATA taskfile to standard ATA host controller.
 *
 *	This is to fix the internal bug of via chipsets, which will
 *	reset the device register after changing the IEN bit on ctl
 *	register.
 */
static void svia_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
{
	struct ata_taskfile ttf;

	if (tf->ctl != ap->last_ctl)  {
		ttf = *tf;
		ttf.flags |= ATA_TFLAG_DEVICE;
		tf = &ttf;
	}
	ata_sff_tf_load(ap, tf);
}

304 305 306 307 308
static void svia_noop_freeze(struct ata_port *ap)
{
	/* Some VIA controllers choke if ATA_NIEN is manipulated in
	 * certain way.  Leave it alone and just clear pending IRQ.
	 */
Tejun Heo's avatar
Tejun Heo committed
309
	ap->ops->sff_check_status(ap);
310
	ata_bmdma_irq_clear(ap);
311 312
}

313 314
/**
 *	vt6420_prereset - prereset for vt6420
Tejun Heo's avatar
Tejun Heo committed
315
 *	@link: target ATA link
316
 *	@deadline: deadline jiffies for the operation
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
 *
 *	SCR registers on vt6420 are pieces of shit and may hang the
 *	whole machine completely if accessed with the wrong timing.
 *	To avoid such catastrophe, vt6420 doesn't provide generic SCR
 *	access operations, but uses SStatus and SControl only during
 *	boot probing in controlled way.
 *
 *	As the old (pre EH update) probing code is proven to work, we
 *	strictly follow the access pattern.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep)
 *
 *	RETURNS:
 *	0 on success, -errno otherwise.
 */
Tejun Heo's avatar
Tejun Heo committed
333
static int vt6420_prereset(struct ata_link *link, unsigned long deadline)
334
{
Tejun Heo's avatar
Tejun Heo committed
335
	struct ata_port *ap = link->ap;
336
	struct ata_eh_context *ehc = &ap->link.eh_context;
337 338 339 340 341
	unsigned long timeout = jiffies + (HZ * 5);
	u32 sstatus, scontrol;
	int online;

	/* don't do any SCR stuff if we're not loading */
342
	if (!(ap->pflags & ATA_PFLAG_LOADING))
343 344
		goto skip_scr;

345
	/* Resume phy.  This is the old SATA resume sequence */
346 347
	svia_scr_write(link, SCR_CONTROL, 0x300);
	svia_scr_read(link, SCR_CONTROL, &scontrol); /* flush */
348 349 350

	/* wait for phy to become ready, if necessary */
	do {
351
		ata_msleep(link->ap, 200);
352
		svia_scr_read(link, SCR_STATUS, &sstatus);
353
		if ((sstatus & 0xf) != 1)
354 355 356 357
			break;
	} while (time_before(jiffies, timeout));

	/* open code sata_print_link_status() */
358 359
	svia_scr_read(link, SCR_STATUS, &sstatus);
	svia_scr_read(link, SCR_CONTROL, &scontrol);
360 361 362

	online = (sstatus & 0xf) == 0x3;

363 364 365
	ata_port_info(ap,
		      "SATA link %s 1.5 Gbps (SStatus %X SControl %X)\n",
		      online ? "up" : "down", sstatus, scontrol);
366 367

	/* SStatus is read one more time */
368
	svia_scr_read(link, SCR_STATUS, &sstatus);
369 370 371

	if (!online) {
		/* tell EH to bail */
Tejun Heo's avatar
Tejun Heo committed
372
		ehc->i.action &= ~ATA_EH_RESET;
373 374 375 376 377
		return 0;
	}

 skip_scr:
	/* wait for !BSY */
378
	ata_sff_wait_ready(link, deadline);
379 380 381 382

	return 0;
}

383 384 385 386 387 388 389 390 391 392 393
static void vt6420_bmdma_start(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	if ((qc->tf.command == ATA_CMD_PACKET) &&
	    (qc->scsicmd->sc_data_direction == DMA_TO_DEVICE)) {
		/* Prevents corruption on some ATAPI burners */
		ata_sff_pause(ap);
	}
	ata_bmdma_start(qc);
}

394
static int vt6421_pata_cable_detect(struct ata_port *ap)
Alan's avatar
Alan committed
395 396 397 398 399 400
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 tmp;

	pci_read_config_byte(pdev, PATA_UDMA_TIMING, &tmp);
	if (tmp & 0x10)
401 402
		return ATA_CBL_PATA40;
	return ATA_CBL_PATA80;
Alan's avatar
Alan committed
403 404 405 406 407 408
}

static void vt6421_set_pio_mode(struct ata_port *ap, struct ata_device *adev)
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	static const u8 pio_bits[] = { 0xA8, 0x65, 0x65, 0x31, 0x20 };
409 410
	pci_write_config_byte(pdev, PATA_PIO_TIMING - adev->devno,
			      pio_bits[adev->pio_mode - XFER_PIO_0]);
Alan's avatar
Alan committed
411 412 413 414 415 416
}

static void vt6421_set_dma_mode(struct ata_port *ap, struct ata_device *adev)
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	static const u8 udma_bits[] = { 0xEE, 0xE8, 0xE6, 0xE4, 0xE2, 0xE1, 0xE0, 0xE0 };
417 418
	pci_write_config_byte(pdev, PATA_UDMA_TIMING - adev->devno,
			      udma_bits[adev->dma_mode - XFER_UDMA_0]);
Alan's avatar
Alan committed
419 420
}

Linus Torvalds's avatar
Linus Torvalds committed
421 422 423 424 425 426 427 428
static const unsigned int svia_bar_sizes[] = {
	8, 4, 8, 4, 16, 256
};

static const unsigned int vt6421_bar_sizes[] = {
	16, 16, 16, 16, 32, 128
};

429
static void __iomem *svia_scr_addr(void __iomem *addr, unsigned int port)
Linus Torvalds's avatar
Linus Torvalds committed
430 431 432 433
{
	return addr + (port * 128);
}

434
static void __iomem *vt6421_scr_addr(void __iomem *addr, unsigned int port)
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438
{
	return addr + (port * 64);
}

439
static void vt6421_init_addrs(struct ata_port *ap)
Linus Torvalds's avatar
Linus Torvalds committed
440
{
441 442 443 444 445 446 447 448
	void __iomem * const * iomap = ap->host->iomap;
	void __iomem *reg_addr = iomap[ap->port_no];
	void __iomem *bmdma_addr = iomap[4] + (ap->port_no * 8);
	struct ata_ioports *ioaddr = &ap->ioaddr;

	ioaddr->cmd_addr = reg_addr;
	ioaddr->altstatus_addr =
	ioaddr->ctl_addr = (void __iomem *)
Tejun Heo's avatar
Tejun Heo committed
449
		((unsigned long)(reg_addr + 8) | ATA_PCI_CTL_OFS);
450 451
	ioaddr->bmdma_addr = bmdma_addr;
	ioaddr->scr_addr = vt6421_scr_addr(iomap[5], ap->port_no);
Linus Torvalds's avatar
Linus Torvalds committed
452

Tejun Heo's avatar
Tejun Heo committed
453
	ata_sff_std_ports(ioaddr);
454 455 456

	ata_port_pbar_desc(ap, ap->port_no, -1, "port");
	ata_port_pbar_desc(ap, 4, ap->port_no * 8, "bmdma");
Linus Torvalds's avatar
Linus Torvalds committed
457 458
}

459
static int vt6420_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
Linus Torvalds's avatar
Linus Torvalds committed
460
{
461 462 463
	const struct ata_port_info *ppi[] = { &vt6420_port_info, NULL };
	struct ata_host *host;
	int rc;
464

465
	rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
466 467 468
	if (rc)
		return rc;
	*r_host = host;
Linus Torvalds's avatar
Linus Torvalds committed
469

470 471
	rc = pcim_iomap_regions(pdev, 1 << 5, DRV_NAME);
	if (rc) {
472
		dev_err(&pdev->dev, "failed to iomap PCI BAR 5\n");
473
		return rc;
474 475
	}

476 477
	host->ports[0]->ioaddr.scr_addr = svia_scr_addr(host->iomap[5], 0);
	host->ports[1]->ioaddr.scr_addr = svia_scr_addr(host->iomap[5], 1);
Linus Torvalds's avatar
Linus Torvalds committed
478

479
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
480 481
}

482
static int vt6421_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
Linus Torvalds's avatar
Linus Torvalds committed
483
{
484 485 486 487 488 489 490
	const struct ata_port_info *ppi[] =
		{ &vt6421_sport_info, &vt6421_sport_info, &vt6421_pport_info };
	struct ata_host *host;
	int i, rc;

	*r_host = host = ata_host_alloc_pinfo(&pdev->dev, ppi, ARRAY_SIZE(ppi));
	if (!host) {
491
		dev_err(&pdev->dev, "failed to allocate host\n");
492 493
		return -ENOMEM;
	}
Linus Torvalds's avatar
Linus Torvalds committed
494

495
	rc = pcim_iomap_regions(pdev, 0x3f, DRV_NAME);
496
	if (rc) {
497 498
		dev_err(&pdev->dev, "failed to request/iomap PCI BARs (errno=%d)\n",
			rc);
499 500 501
		return rc;
	}
	host->iomap = pcim_iomap_table(pdev);
502

503 504
	for (i = 0; i < host->n_ports; i++)
		vt6421_init_addrs(host->ports[i]);
Linus Torvalds's avatar
Linus Torvalds committed
505

506 507 508 509 510 511 512 513
	rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
	if (rc)
		return rc;
	rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
	if (rc)
		return rc;

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
514 515
}

516 517 518 519 520 521
static int vt8251_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
{
	const struct ata_port_info *ppi[] = { &vt8251_port_info, NULL };
	struct ata_host *host;
	int i, rc;

522
	rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
523 524 525 526 527 528
	if (rc)
		return rc;
	*r_host = host;

	rc = pcim_iomap_regions(pdev, 1 << 5, DRV_NAME);
	if (rc) {
529
		dev_err(&pdev->dev, "failed to iomap PCI BAR 5\n");
530 531 532 533 534 535 536 537 538 539
		return rc;
	}

	/* 8251 hosts four sata ports as M/S of the two channels */
	for (i = 0; i < host->n_ports; i++)
		ata_slave_link_init(host->ports[i]);

	return 0;
}

540
static void svia_configure(struct pci_dev *pdev, int board_id)
Linus Torvalds's avatar
Linus Torvalds committed
541 542 543 544
{
	u8 tmp8;

	pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
545 546
	dev_info(&pdev->dev, "routed to hard irq line %d\n",
		 (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
Linus Torvalds's avatar
Linus Torvalds committed
547 548 549 550

	/* make sure SATA channels are enabled */
	pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
	if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
Joe Perches's avatar
Joe Perches committed
551 552
		dev_dbg(&pdev->dev, "enabling SATA channels (0x%x)\n",
			(int)tmp8);
Linus Torvalds's avatar
Linus Torvalds committed
553 554 555 556 557 558 559
		tmp8 |= ALL_PORTS;
		pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
	}

	/* make sure interrupts for each channel sent to us */
	pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
	if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
Joe Perches's avatar
Joe Perches committed
560 561
		dev_dbg(&pdev->dev, "enabling SATA channel interrupts (0x%x)\n",
			(int) tmp8);
Linus Torvalds's avatar
Linus Torvalds committed
562 563 564 565 566 567 568
		tmp8 |= ALL_PORTS;
		pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
	}

	/* make sure native mode is enabled */
	pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
	if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
Joe Perches's avatar
Joe Perches committed
569 570 571
		dev_dbg(&pdev->dev,
			"enabling SATA channel native mode (0x%x)\n",
			(int) tmp8);
Linus Torvalds's avatar
Linus Torvalds committed
572 573 574
		tmp8 |= NATIVE_MODE_ALL;
		pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
	}
575 576

	/*
577
	 * vt6420/1 has problems talking to some drives.  The following
578 579 580 581 582
	 * is the fix from Joseph Chan <JosephChan@via.com.tw>.
	 *
	 * When host issues HOLD, device may send up to 20DW of data
	 * before acknowledging it with HOLDA and the host should be
	 * able to buffer them in FIFO.  Unfortunately, some WD drives
583
	 * send up to 40DW before acknowledging HOLD and, in the
584 585 586 587 588 589 590 591 592
	 * default configuration, this ends up overflowing vt6421's
	 * FIFO, making the controller abort the transaction with
	 * R_ERR.
	 *
	 * Rx52[2] is the internal 128DW FIFO Flow control watermark
	 * adjusting mechanism enable bit and the default value 0
	 * means host will issue HOLD to device when the left FIFO
	 * size goes below 32DW.  Setting it to 1 makes the watermark
	 * 64DW.
593 594
	 *
	 * https://bugzilla.kernel.org/show_bug.cgi?id=15173
595
	 * http://article.gmane.org/gmane.linux.ide/46352
596
	 * http://thread.gmane.org/gmane.linux.kernel/1062139
597
	 */
598
	if (board_id == vt6420 || board_id == vt6421) {
599 600 601 602
		pci_read_config_byte(pdev, 0x52, &tmp8);
		tmp8 |= 1 << 2;
		pci_write_config_byte(pdev, 0x52, tmp8);
	}
Linus Torvalds's avatar
Linus Torvalds committed
603 604
}

605
static int svia_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608
{
	unsigned int i;
	int rc;
609
	struct ata_host *host = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
610
	int board_id = (int) ent->driver_data;
611
	const unsigned *bar_sizes;
Linus Torvalds's avatar
Linus Torvalds committed
612

613
	ata_print_version_once(&pdev->dev, DRV_VERSION);
Linus Torvalds's avatar
Linus Torvalds committed
614

615
	rc = pcim_enable_device(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
616 617 618
	if (rc)
		return rc;

619
	if (board_id == vt6421)
Linus Torvalds's avatar
Linus Torvalds committed
620
		bar_sizes = &vt6421_bar_sizes[0];
621 622
	else
		bar_sizes = &svia_bar_sizes[0];
Linus Torvalds's avatar
Linus Torvalds committed
623 624 625 626

	for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
		if ((pci_resource_start(pdev, i) == 0) ||
		    (pci_resource_len(pdev, i) < bar_sizes[i])) {
627
			dev_err(&pdev->dev,
628 629
				"invalid PCI BAR %u (sz 0x%llx, val 0x%llx)\n",
				i,
630 631
				(unsigned long long)pci_resource_start(pdev, i),
				(unsigned long long)pci_resource_len(pdev, i));
632
			return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
633 634
		}

635 636
	switch (board_id) {
	case vt6420:
637
		rc = vt6420_prepare_host(pdev, &host);
638 639
		break;
	case vt6421:
640
		rc = vt6421_prepare_host(pdev, &host);
641 642 643 644 645
		break;
	case vt8251:
		rc = vt8251_prepare_host(pdev, &host);
		break;
	default:
646
		rc = -EINVAL;
647
	}
648 649
	if (rc)
		return rc;
Linus Torvalds's avatar
Linus Torvalds committed
650

651
	svia_configure(pdev, board_id);
Linus Torvalds's avatar
Linus Torvalds committed
652 653

	pci_set_master(pdev);
654
	return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
Tejun Heo's avatar
Tejun Heo committed
655
				 IRQF_SHARED, &svia_sht);
Linus Torvalds's avatar
Linus Torvalds committed
656 657
}

Axel Lin's avatar
Axel Lin committed
658
module_pci_driver(svia_pci_driver);