sata_via.c 21 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
 *
 *  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',
28
 *  as Documentation/driver-api/libata.rst
29 30 31 32 33
 *
 *  Hardware documentation available under NDA.
 *
 *
 *
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36 37 38 39 40
 */

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

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

Tejun Heo's avatar
Tejun Heo committed
50 51 52 53
/*
 * 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
54 55 56
enum board_ids_enum {
	vt6420,
	vt6421,
Tejun Heo's avatar
Tejun Heo committed
57
	vt8251,
Linus Torvalds's avatar
Linus Torvalds committed
58 59 60 61 62 63
};

enum {
	SATA_CHAN_ENAB		= 0x40, /* SATA channel enable */
	SATA_INT_GATE		= 0x41, /* SATA interrupt gating */
	SATA_NATIVE_MODE	= 0x42, /* Native mode enable */
64
	SVIA_MISC_3		= 0x46,	/* Miscellaneous Control III */
Alan Cox Cox's avatar
Alan Cox Cox 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
	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 */
75 76

	SATA_HOTPLUG		= (1 << 5), /* enable IRQ on hotplug */
Linus Torvalds's avatar
Linus Torvalds committed
77 78
};

79 80 81 82
struct svia_priv {
	bool			wd_workaround;
};

83 84 85 86
static int vt6420_hotplug;
module_param_named(vt6420_hotplug, vt6420_hotplug, int, 0644);
MODULE_PARM_DESC(vt6420_hotplug, "Enable hot-plug support for VT6420 (0=Don't support, 1=support)");

87
static int svia_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
88 89 90
#ifdef CONFIG_PM_SLEEP
static int svia_pci_device_resume(struct pci_dev *pdev);
#endif
91 92
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);
Tejun Heo's avatar
Tejun Heo committed
93 94
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);
95
static void svia_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
96
static void svia_noop_freeze(struct ata_port *ap);
97
static int vt6420_prereset(struct ata_link *link, unsigned long deadline);
98
static void vt6420_bmdma_start(struct ata_queued_cmd *qc);
99
static int vt6421_pata_cable_detect(struct ata_port *ap);
Alan Cox Cox's avatar
Alan Cox Cox committed
100 101
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);
102
static void vt6421_error_handler(struct ata_port *ap);
Linus Torvalds's avatar
Linus Torvalds committed
103

104
static const struct pci_device_id svia_pci_tbl[] = {
Luca Pedrielli's avatar
Luca Pedrielli committed
105
	{ PCI_VDEVICE(VIA, 0x5337), vt6420 },
Tejun Heo's avatar
Tejun Heo committed
106 107 108
	{ 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 */
109 110
	{ PCI_VDEVICE(VIA, 0x5372), vt6420 },
	{ PCI_VDEVICE(VIA, 0x7372), vt6420 },
Tejun Heo's avatar
Tejun Heo committed
111
	{ PCI_VDEVICE(VIA, 0x5287), vt8251 }, /* 2 sata chnls (Master/Slave) */
112
	{ PCI_VDEVICE(VIA, 0x9000), vt8251 },
Linus Torvalds's avatar
Linus Torvalds committed
113 114 115 116 117 118 119 120

	{ }	/* terminate list */
};

static struct pci_driver svia_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= svia_pci_tbl,
	.probe			= svia_init_one,
121
#ifdef CONFIG_PM_SLEEP
Tejun Heo's avatar
Tejun Heo committed
122
	.suspend		= ata_pci_device_suspend,
123
	.resume			= svia_pci_device_resume,
Tejun Heo's avatar
Tejun Heo committed
124
#endif
Linus Torvalds's avatar
Linus Torvalds committed
125 126 127
	.remove			= ata_pci_remove_one,
};

128
static struct scsi_host_template svia_sht = {
129
	ATA_BMDMA_SHT(DRV_NAME),
Linus Torvalds's avatar
Linus Torvalds committed
130 131
};

132
static struct ata_port_operations svia_base_ops = {
133
	.inherits		= &ata_bmdma_port_ops,
134 135 136 137 138
	.sff_tf_load		= svia_tf_load,
};

static struct ata_port_operations vt6420_sata_ops = {
	.inherits		= &svia_base_ops,
139
	.freeze			= svia_noop_freeze,
140
	.prereset		= vt6420_prereset,
141
	.bmdma_start		= vt6420_bmdma_start,
142 143
};

144
static struct ata_port_operations vt6421_pata_ops = {
145
	.inherits		= &svia_base_ops,
146
	.cable_detect		= vt6421_pata_cable_detect,
Alan Cox Cox's avatar
Alan Cox Cox committed
147 148 149 150
	.set_piomode		= vt6421_set_pio_mode,
	.set_dmamode		= vt6421_set_dma_mode,
};

151
static struct ata_port_operations vt6421_sata_ops = {
152
	.inherits		= &svia_base_ops,
Linus Torvalds's avatar
Linus Torvalds committed
153 154
	.scr_read		= svia_scr_read,
	.scr_write		= svia_scr_write,
155
	.error_handler		= vt6421_error_handler,
Linus Torvalds's avatar
Linus Torvalds committed
156 157
};

Tejun Heo's avatar
Tejun Heo committed
158 159 160 161 162 163 164
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,
};

165
static const struct ata_port_info vt6420_port_info = {
166
	.flags		= ATA_FLAG_SATA,
167 168
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
169
	.udma_mask	= ATA_UDMA6,
170
	.port_ops	= &vt6420_sata_ops,
Linus Torvalds's avatar
Linus Torvalds committed
171 172
};

173
static const struct ata_port_info vt6421_sport_info = {
174
	.flags		= ATA_FLAG_SATA,
175 176
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
177
	.udma_mask	= ATA_UDMA6,
178 179 180
	.port_ops	= &vt6421_sata_ops,
};

181
static const struct ata_port_info vt6421_pport_info = {
182
	.flags		= ATA_FLAG_SLAVE_POSS,
183 184
	.pio_mask	= ATA_PIO4,
	/* No MWDMA */
185
	.udma_mask	= ATA_UDMA6,
186 187 188
	.port_ops	= &vt6421_pata_ops,
};

189
static const struct ata_port_info vt8251_port_info = {
190
	.flags		= ATA_FLAG_SATA | ATA_FLAG_SLAVE_POSS,
191 192
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
Tejun Heo's avatar
Tejun Heo committed
193 194 195 196
	.udma_mask	= ATA_UDMA6,
	.port_ops	= &vt8251_ops,
};

Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202
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);

203
static int svia_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
Linus Torvalds's avatar
Linus Torvalds committed
204 205
{
	if (sc_reg > SCR_CONTROL)
206
		return -EINVAL;
207
	*val = ioread32(link->ap->ioaddr.scr_addr + (4 * sc_reg));
208
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
209 210
}

211
static int svia_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
Linus Torvalds's avatar
Linus Torvalds committed
212 213
{
	if (sc_reg > SCR_CONTROL)
214
		return -EINVAL;
215
	iowrite32(val, link->ap->ioaddr.scr_addr + (4 * sc_reg));
216
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
217 218
}

Tejun Heo's avatar
Tejun Heo committed
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 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
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;
	}
}

296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
/**
 *	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);
}

319 320 321 322 323
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
324
	ap->ops->sff_check_status(ap);
325
	ata_bmdma_irq_clear(ap);
326 327
}

328 329
/**
 *	vt6420_prereset - prereset for vt6420
Tejun Heo's avatar
Tejun Heo committed
330
 *	@link: target ATA link
331
 *	@deadline: deadline jiffies for the operation
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
 *
 *	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
348
static int vt6420_prereset(struct ata_link *link, unsigned long deadline)
349
{
Tejun Heo's avatar
Tejun Heo committed
350
	struct ata_port *ap = link->ap;
Tejun Heo's avatar
Tejun Heo committed
351
	struct ata_eh_context *ehc = &ap->link.eh_context;
352 353 354 355 356
	unsigned long timeout = jiffies + (HZ * 5);
	u32 sstatus, scontrol;
	int online;

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

360
	/* Resume phy.  This is the old SATA resume sequence */
361 362
	svia_scr_write(link, SCR_CONTROL, 0x300);
	svia_scr_read(link, SCR_CONTROL, &scontrol); /* flush */
363 364 365

	/* wait for phy to become ready, if necessary */
	do {
366
		ata_msleep(link->ap, 200);
367
		svia_scr_read(link, SCR_STATUS, &sstatus);
368
		if ((sstatus & 0xf) != 1)
369 370 371 372
			break;
	} while (time_before(jiffies, timeout));

	/* open code sata_print_link_status() */
373 374
	svia_scr_read(link, SCR_STATUS, &sstatus);
	svia_scr_read(link, SCR_CONTROL, &scontrol);
375 376 377

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

378 379 380
	ata_port_info(ap,
		      "SATA link %s 1.5 Gbps (SStatus %X SControl %X)\n",
		      online ? "up" : "down", sstatus, scontrol);
381 382

	/* SStatus is read one more time */
383
	svia_scr_read(link, SCR_STATUS, &sstatus);
384 385 386

	if (!online) {
		/* tell EH to bail */
Tejun Heo's avatar
Tejun Heo committed
387
		ehc->i.action &= ~ATA_EH_RESET;
388 389 390 391 392
		return 0;
	}

 skip_scr:
	/* wait for !BSY */
393
	ata_sff_wait_ready(link, deadline);
394 395 396 397

	return 0;
}

398 399 400 401 402 403 404 405 406 407 408
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);
}

409
static int vt6421_pata_cable_detect(struct ata_port *ap)
Alan Cox Cox's avatar
Alan Cox Cox committed
410 411 412 413 414 415
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 tmp;

	pci_read_config_byte(pdev, PATA_UDMA_TIMING, &tmp);
	if (tmp & 0x10)
416 417
		return ATA_CBL_PATA40;
	return ATA_CBL_PATA80;
Alan Cox Cox's avatar
Alan Cox Cox committed
418 419 420 421 422 423
}

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 };
424 425
	pci_write_config_byte(pdev, PATA_PIO_TIMING - adev->devno,
			      pio_bits[adev->pio_mode - XFER_PIO_0]);
Alan Cox Cox's avatar
Alan Cox Cox committed
426 427 428 429 430 431
}

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 };
432 433
	pci_write_config_byte(pdev, PATA_UDMA_TIMING - adev->devno,
			      udma_bits[adev->dma_mode - XFER_UDMA_0]);
Alan Cox Cox's avatar
Alan Cox Cox committed
434 435
}

Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440 441 442 443
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
};

444
static void __iomem *svia_scr_addr(void __iomem *addr, unsigned int port)
Linus Torvalds's avatar
Linus Torvalds committed
445 446 447 448
{
	return addr + (port * 128);
}

449
static void __iomem *vt6421_scr_addr(void __iomem *addr, unsigned int port)
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453
{
	return addr + (port * 64);
}

454
static void vt6421_init_addrs(struct ata_port *ap)
Linus Torvalds's avatar
Linus Torvalds committed
455
{
456 457 458 459 460 461 462 463
	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
464
		((unsigned long)(reg_addr + 8) | ATA_PCI_CTL_OFS);
465 466
	ioaddr->bmdma_addr = bmdma_addr;
	ioaddr->scr_addr = vt6421_scr_addr(iomap[5], ap->port_no);
Linus Torvalds's avatar
Linus Torvalds committed
467

Tejun Heo's avatar
Tejun Heo committed
468
	ata_sff_std_ports(ioaddr);
469 470 471

	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
472 473
}

474
static int vt6420_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
Linus Torvalds's avatar
Linus Torvalds committed
475
{
476 477 478
	const struct ata_port_info *ppi[] = { &vt6420_port_info, NULL };
	struct ata_host *host;
	int rc;
479

480 481 482 483 484
	if (vt6420_hotplug) {
		ppi[0]->port_ops->scr_read = svia_scr_read;
		ppi[0]->port_ops->scr_write = svia_scr_write;
	}

485
	rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
486 487 488
	if (rc)
		return rc;
	*r_host = host;
Linus Torvalds's avatar
Linus Torvalds committed
489

490 491
	rc = pcim_iomap_regions(pdev, 1 << 5, DRV_NAME);
	if (rc) {
492
		dev_err(&pdev->dev, "failed to iomap PCI BAR 5\n");
493
		return rc;
494 495
	}

496 497
	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
498

499
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
500 501
}

502
static int vt6421_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
Linus Torvalds's avatar
Linus Torvalds committed
503
{
504 505 506 507 508 509 510
	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) {
511
		dev_err(&pdev->dev, "failed to allocate host\n");
512 513
		return -ENOMEM;
	}
Linus Torvalds's avatar
Linus Torvalds committed
514

515
	rc = pcim_iomap_regions(pdev, 0x3f, DRV_NAME);
516
	if (rc) {
517 518
		dev_err(&pdev->dev, "failed to request/iomap PCI BARs (errno=%d)\n",
			rc);
519 520 521
		return rc;
	}
	host->iomap = pcim_iomap_table(pdev);
522

523 524
	for (i = 0; i < host->n_ports; i++)
		vt6421_init_addrs(host->ports[i]);
Linus Torvalds's avatar
Linus Torvalds committed
525

526
	rc = dma_set_mask(&pdev->dev, ATA_DMA_MASK);
527 528
	if (rc)
		return rc;
529
	rc = dma_set_coherent_mask(&pdev->dev, ATA_DMA_MASK);
530 531 532 533
	if (rc)
		return rc;

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
534 535
}

Tejun Heo's avatar
Tejun Heo committed
536 537 538 539 540 541
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;

542
	rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
Tejun Heo's avatar
Tejun Heo committed
543 544 545 546 547 548
	if (rc)
		return rc;
	*r_host = host;

	rc = pcim_iomap_regions(pdev, 1 << 5, DRV_NAME);
	if (rc) {
549
		dev_err(&pdev->dev, "failed to iomap PCI BAR 5\n");
Tejun Heo's avatar
Tejun Heo committed
550 551 552 553 554 555 556 557 558 559
		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;
}

560 561 562 563 564 565 566 567
static void svia_wd_fix(struct pci_dev *pdev)
{
	u8 tmp8;

	pci_read_config_byte(pdev, 0x52, &tmp8);
	pci_write_config_byte(pdev, 0x52, tmp8 | BIT(2));
}

568
static irqreturn_t vt642x_interrupt(int irq, void *dev_instance)
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
{
	struct ata_host *host = dev_instance;
	irqreturn_t rc = ata_bmdma_interrupt(irq, dev_instance);

	/* if the IRQ was not handled, it might be a hotplug IRQ */
	if (rc != IRQ_HANDLED) {
		u32 serror;
		unsigned long flags;

		spin_lock_irqsave(&host->lock, flags);
		/* check for hotplug on port 0 */
		svia_scr_read(&host->ports[0]->link, SCR_ERROR, &serror);
		if (serror & SERR_PHYRDY_CHG) {
			ata_ehi_hotplugged(&host->ports[0]->link.eh_info);
			ata_port_freeze(host->ports[0]);
			rc = IRQ_HANDLED;
		}
		/* check for hotplug on port 1 */
		svia_scr_read(&host->ports[1]->link, SCR_ERROR, &serror);
		if (serror & SERR_PHYRDY_CHG) {
			ata_ehi_hotplugged(&host->ports[1]->link.eh_info);
			ata_port_freeze(host->ports[1]);
			rc = IRQ_HANDLED;
		}
		spin_unlock_irqrestore(&host->lock, flags);
	}

	return rc;
}

599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
static void vt6421_error_handler(struct ata_port *ap)
{
	struct svia_priv *hpriv = ap->host->private_data;
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u32 serror;

	/* see svia_configure() for description */
	if (!hpriv->wd_workaround) {
		svia_scr_read(&ap->link, SCR_ERROR, &serror);
		if (serror == 0x1000500) {
			ata_port_warn(ap, "Incompatible drive: enabling workaround. This slows down transfer rate to ~60 MB/s");
			svia_wd_fix(pdev);
			hpriv->wd_workaround = true;
			ap->link.eh_context.i.flags |= ATA_EHI_QUIET;
		}
	}

	ata_sff_error_handler(ap);
}

static void svia_configure(struct pci_dev *pdev, int board_id,
			   struct svia_priv *hpriv)
Linus Torvalds's avatar
Linus Torvalds committed
621 622 623 624
{
	u8 tmp8;

	pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
625 626
	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
627 628 629 630

	/* 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
631 632
		dev_dbg(&pdev->dev, "enabling SATA channels (0x%x)\n",
			(int)tmp8);
Linus Torvalds's avatar
Linus Torvalds committed
633 634 635 636 637 638 639
		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
640 641
		dev_dbg(&pdev->dev, "enabling SATA channel interrupts (0x%x)\n",
			(int) tmp8);
Linus Torvalds's avatar
Linus Torvalds committed
642 643 644 645 646 647 648
		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
649 650 651
		dev_dbg(&pdev->dev,
			"enabling SATA channel native mode (0x%x)\n",
			(int) tmp8);
Linus Torvalds's avatar
Linus Torvalds committed
652 653 654
		tmp8 |= NATIVE_MODE_ALL;
		pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
	}
655

656
	if ((board_id == vt6420 && vt6420_hotplug) || board_id == vt6421) {
657 658 659 660 661 662 663 664 665
		/* enable IRQ on hotplug */
		pci_read_config_byte(pdev, SVIA_MISC_3, &tmp8);
		if ((tmp8 & SATA_HOTPLUG) != SATA_HOTPLUG) {
			dev_dbg(&pdev->dev,
				"enabling SATA hotplug (0x%x)\n",
				(int) tmp8);
			tmp8 |= SATA_HOTPLUG;
			pci_write_config_byte(pdev, SVIA_MISC_3, tmp8);
		}
666 667
	}

668
	/*
669
	 * vt6420/1 has problems talking to some drives.  The following
Tejun Heo's avatar
Tejun Heo committed
670 671 672 673 674
	 * 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
Lucas De Marchi's avatar
Lucas De Marchi committed
675
	 * send up to 40DW before acknowledging HOLD and, in the
Tejun Heo's avatar
Tejun Heo committed
676 677 678 679 680 681 682 683 684
	 * 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.
685 686
	 *
	 * https://bugzilla.kernel.org/show_bug.cgi?id=15173
Tejun Heo's avatar
Tejun Heo committed
687
	 * http://article.gmane.org/gmane.linux.ide/46352
688
	 * http://thread.gmane.org/gmane.linux.kernel/1062139
689 690 691 692 693
	 *
	 * As the fix slows down data transfer, apply it only if the error
	 * actually appears - see vt6421_error_handler()
	 * Apply the fix always on vt6420 as we don't know if SCR_ERROR can be
	 * read safely.
694
	 */
695 696 697
	if (board_id == vt6420) {
		svia_wd_fix(pdev);
		hpriv->wd_workaround = true;
698
	}
Linus Torvalds's avatar
Linus Torvalds committed
699 700
}

701
static int svia_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
Linus Torvalds's avatar
Linus Torvalds committed
702 703 704
{
	unsigned int i;
	int rc;
705
	struct ata_host *host = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
706
	int board_id = (int) ent->driver_data;
707
	const unsigned *bar_sizes;
708
	struct svia_priv *hpriv;
Linus Torvalds's avatar
Linus Torvalds committed
709

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

712
	rc = pcim_enable_device(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
713 714 715
	if (rc)
		return rc;

Tejun Heo's avatar
Tejun Heo committed
716
	if (board_id == vt6421)
Linus Torvalds's avatar
Linus Torvalds committed
717
		bar_sizes = &vt6421_bar_sizes[0];
Tejun Heo's avatar
Tejun Heo committed
718 719
	else
		bar_sizes = &svia_bar_sizes[0];
Linus Torvalds's avatar
Linus Torvalds committed
720 721 722 723

	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])) {
724
			dev_err(&pdev->dev,
725 726
				"invalid PCI BAR %u (sz 0x%llx, val 0x%llx)\n",
				i,
727 728
				(unsigned long long)pci_resource_start(pdev, i),
				(unsigned long long)pci_resource_len(pdev, i));
729
			return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
730 731
		}

Tejun Heo's avatar
Tejun Heo committed
732 733
	switch (board_id) {
	case vt6420:
734
		rc = vt6420_prepare_host(pdev, &host);
Tejun Heo's avatar
Tejun Heo committed
735 736
		break;
	case vt6421:
737
		rc = vt6421_prepare_host(pdev, &host);
Tejun Heo's avatar
Tejun Heo committed
738 739 740 741 742
		break;
	case vt8251:
		rc = vt8251_prepare_host(pdev, &host);
		break;
	default:
743
		rc = -EINVAL;
Tejun Heo's avatar
Tejun Heo committed
744
	}
745 746
	if (rc)
		return rc;
Linus Torvalds's avatar
Linus Torvalds committed
747

748 749 750 751 752 753
	hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
	if (!hpriv)
		return -ENOMEM;
	host->private_data = hpriv;

	svia_configure(pdev, board_id, hpriv);
Linus Torvalds's avatar
Linus Torvalds committed
754 755

	pci_set_master(pdev);
756 757
	if ((board_id == vt6420 && vt6420_hotplug) || board_id == vt6421)
		return ata_host_activate(host, pdev->irq, vt642x_interrupt,
758 759 760 761
					 IRQF_SHARED, &svia_sht);
	else
		return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
					 IRQF_SHARED, &svia_sht);
Linus Torvalds's avatar
Linus Torvalds committed
762 763
}

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
#ifdef CONFIG_PM_SLEEP
static int svia_pci_device_resume(struct pci_dev *pdev)
{
	struct ata_host *host = pci_get_drvdata(pdev);
	struct svia_priv *hpriv = host->private_data;
	int rc;

	rc = ata_pci_device_do_resume(pdev);
	if (rc)
		return rc;

	if (hpriv->wd_workaround)
		svia_wd_fix(pdev);
	ata_host_resume(host);

	return 0;
}
#endif

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