[linux.git] / drivers / scsi / sata_via.c

/*
   sata_via.c - VIA Serial ATA controllers

   Maintained by:  Jeff Garzik <[email protected]>
   		   Please ALWAYS copy [email protected]
 		   on emails.

   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   Copyright 2003-2004 Jeff Garzik

   The contents of this file are subject to the Open
   Software License version 1.1 that can be found at
   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
   by reference.

   Alternatively, the contents of this file may be used under the terms
   of the GNU General Public License version 2 (the "GPL") as distributed
   in the kernel source COPYING file, in which case the provisions of
   the GPL are applicable instead of the above.  If you wish to allow
   the use of your version of this file only under the terms of the
   GPL and not to allow others to use your version of this file under
   the OSL, indicate your decision by deleting the provisions above and
   replace them with the notice and other provisions required by the GPL.
   If you do not delete the provisions above, a recipient may use your
   version of this file under either the OSL or the GPL.

   ----------------------------------------------------------------------

   To-do list:
   * VT6421 PATA support

 */

#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 "scsi.h"
#include <scsi/scsi_host.h>
#include <linux/libata.h>
#include <asm/io.h>

#define DRV_NAME	"sata_via"
#define DRV_VERSION	"1.1"

enum board_ids_enum {
	vt6420,
	vt6421,
};

enum {
	SATA_CHAN_ENAB		= 0x40, /* SATA channel enable */
	SATA_INT_GATE		= 0x41, /* SATA interrupt gating */
	SATA_NATIVE_MODE	= 0x42, /* Native mode enable */
	SATA_PATA_SHARING	= 0x49, /* PATA/SATA sharing func ctrl */

	PORT0			= (1 << 1),
	PORT1			= (1 << 0),
	ALL_PORTS		= PORT0 | PORT1,
	N_PORTS			= 2,

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

	SATA_EXT_PHY		= (1 << 6), /* 0==use PATA, 1==ext phy */
	SATA_2DEV		= (1 << 5), /* SATA is master/slave */
};

static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);

static struct pci_device_id svia_pci_tbl[] = {
	{ 0x1106, 0x3149, PCI_ANY_ID, PCI_ANY_ID, 0, 0, vt6420 },
	{ 0x1106, 0x3249, PCI_ANY_ID, PCI_ANY_ID, 0, 0, vt6421 },

	{ }	/* terminate list */
};

static struct pci_driver svia_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= svia_pci_tbl,
	.probe			= svia_init_one,
	.remove			= ata_pci_remove_one,
};

static Scsi_Host_Template svia_sht = {
	.module			= THIS_MODULE,
	.name			= DRV_NAME,
	.ioctl			= ata_scsi_ioctl,
	.queuecommand		= ata_scsi_queuecmd,
	.eh_strategy_handler	= ata_scsi_error,
	.can_queue		= ATA_DEF_QUEUE,
	.this_id		= ATA_SHT_THIS_ID,
	.sg_tablesize		= LIBATA_MAX_PRD,
	.max_sectors		= ATA_MAX_SECTORS,
	.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,
	.bios_param		= ata_std_bios_param,
	.ordered_flush		= 1,
};

static struct ata_port_operations svia_sata_ops = {
	.port_disable		= ata_port_disable,

	.tf_load		= ata_tf_load,
	.tf_read		= ata_tf_read,
	.check_status		= ata_check_status,
	.exec_command		= ata_exec_command,
	.dev_select		= ata_std_dev_select,

	.phy_reset		= sata_phy_reset,

	.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,

	.eng_timeout		= ata_eng_timeout,

	.irq_handler		= ata_interrupt,
	.irq_clear		= ata_bmdma_irq_clear,

	.scr_read		= svia_scr_read,
	.scr_write		= svia_scr_write,

	.port_start		= ata_port_start,
	.port_stop		= ata_port_stop,
	.host_stop		= ata_host_stop,
};

static struct ata_port_info svia_port_info = {
	.sht		= &svia_sht,
	.host_flags	= ATA_FLAG_SATA | ATA_FLAG_SRST | ATA_FLAG_NO_LEGACY,
	.pio_mask	= 0x1f,
	.mwdma_mask	= 0x07,
	.udma_mask	= 0x7f,
	.port_ops	= &svia_sata_ops,
};

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

static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
{
	if (sc_reg > SCR_CONTROL)
		return 0xffffffffU;
	return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
}

static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
{
	if (sc_reg > SCR_CONTROL)
		return;
	outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
}

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

static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
{
	return addr + (port * 128);
}

static unsigned long vt6421_scr_addr(unsigned long addr, unsigned int port)
{
	return addr + (port * 64);
}

static void vt6421_init_addrs(struct ata_probe_ent *probe_ent,
			      struct pci_dev *pdev,
			      unsigned int port)
{
	unsigned long reg_addr = pci_resource_start(pdev, port);
	unsigned long bmdma_addr = pci_resource_start(pdev, 4) + (port * 8);
	unsigned long scr_addr;

	probe_ent->port[port].cmd_addr = reg_addr;
	probe_ent->port[port].altstatus_addr =
	probe_ent->port[port].ctl_addr = (reg_addr + 8) | ATA_PCI_CTL_OFS;
	probe_ent->port[port].bmdma_addr = bmdma_addr;

	scr_addr = vt6421_scr_addr(pci_resource_start(pdev, 5), port);
	probe_ent->port[port].scr_addr = scr_addr;

	ata_std_ports(&probe_ent->port[port]);
}

static struct ata_probe_ent *vt6420_init_probe_ent(struct pci_dev *pdev)
{
	struct ata_probe_ent *probe_ent;
	struct ata_port_info *ppi = &svia_port_info;

	probe_ent = ata_pci_init_native_mode(pdev, &ppi);
	if (!probe_ent)
		return NULL;

	probe_ent->port[0].scr_addr =
		svia_scr_addr(pci_resource_start(pdev, 5), 0);
	probe_ent->port[1].scr_addr =
		svia_scr_addr(pci_resource_start(pdev, 5), 1);

	return probe_ent;
}

static struct ata_probe_ent *vt6421_init_probe_ent(struct pci_dev *pdev)
{
	struct ata_probe_ent *probe_ent;
	unsigned int i;

	probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
	if (!probe_ent)
		return NULL;

	memset(probe_ent, 0, sizeof(*probe_ent));
	probe_ent->dev = pci_dev_to_dev(pdev);
	INIT_LIST_HEAD(&probe_ent->node);

	probe_ent->sht		= &svia_sht;
	probe_ent->host_flags	= ATA_FLAG_SATA | ATA_FLAG_SATA_RESET |
				  ATA_FLAG_NO_LEGACY;
	probe_ent->port_ops	= &svia_sata_ops;
	probe_ent->n_ports	= N_PORTS;
	probe_ent->irq		= pdev->irq;
	probe_ent->irq_flags	= SA_SHIRQ;
	probe_ent->pio_mask	= 0x1f;
	probe_ent->mwdma_mask	= 0x07;
	probe_ent->udma_mask	= 0x7f;

	for (i = 0; i < N_PORTS; i++)
		vt6421_init_addrs(probe_ent, pdev, i);

	return probe_ent;
}

static void svia_configure(struct pci_dev *pdev)
{
	u8 tmp8;

	pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
	printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
	       pci_name(pdev),
	       (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);

	/* make sure SATA channels are enabled */
	pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
	if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
		printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
		       pci_name(pdev), (int) tmp8);
		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) {
		printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
		       pci_name(pdev), (int) tmp8);
		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) {
		printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
		       pci_name(pdev), (int) tmp8);
		tmp8 |= NATIVE_MODE_ALL;
		pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
	}
}

static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
	static int printed_version;
	unsigned int i;
	int rc;
	struct ata_probe_ent *probe_ent;
	int board_id = (int) ent->driver_data;
	const int *bar_sizes;
	int pci_dev_busy = 0;
	u8 tmp8;

	if (!printed_version++)
		printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");

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

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

	if (board_id == vt6420) {
		pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
		if (tmp8 & SATA_2DEV) {
			printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
		       	pci_name(pdev), (int) tmp8);
			rc = -EIO;
			goto err_out_regions;
		}

		bar_sizes = &svia_bar_sizes[0];
	} else {
		bar_sizes = &vt6421_bar_sizes[0];
	}

	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])) {
			printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
			       pci_name(pdev), i,
			       pci_resource_start(pdev, i),
			       pci_resource_len(pdev, i));
			rc = -ENODEV;
			goto err_out_regions;
		}

	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;

	if (board_id == vt6420)
		probe_ent = vt6420_init_probe_ent(pdev);
	else
		probe_ent = vt6421_init_probe_ent(pdev);
	
	if (!probe_ent) {
		printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
		       pci_name(pdev));
		rc = -ENOMEM;
		goto err_out_regions;
	}

	svia_configure(pdev);

	pci_set_master(pdev);

	/* FIXME: check ata_device_add return value */
	ata_device_add(probe_ent);
	kfree(probe_ent);

	return 0;

err_out_regions:
	pci_release_regions(pdev);
err_out:
	if (!pci_dev_busy)
		pci_disable_device(pdev);
	return rc;
}

static int __init svia_init(void)
{
	return pci_module_init(&svia_pci_driver);
}

static void __exit svia_exit(void)
{
	pci_unregister_driver(&svia_pci_driver);
}

module_init(svia_init);
module_exit(svia_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	sata_via.c - VIA Serial ATA controllers
	3
	4	Maintained by: Jeff Garzik <[email protected]>
	5	Please ALWAYS copy [email protected]
	6	on emails.
	7
	8	Copyright 2003-2004 Red Hat, Inc. All rights reserved.
	9	Copyright 2003-2004 Jeff Garzik
	10
	11	The contents of this file are subject to the Open
	12	Software License version 1.1 that can be found at
	13	http://www.opensource.org/licenses/osl-1.1.txt and is included herein
	14	by reference.
	15
	16	Alternatively, the contents of this file may be used under the terms
	17	of the GNU General Public License version 2 (the "GPL") as distributed
	18	in the kernel source COPYING file, in which case the provisions of
	19	the GPL are applicable instead of the above. If you wish to allow
	20	the use of your version of this file only under the terms of the
	21	GPL and not to allow others to use your version of this file under
	22	the OSL, indicate your decision by deleting the provisions above and
	23	replace them with the notice and other provisions required by the GPL.
	24	If you do not delete the provisions above, a recipient may use your
	25	version of this file under either the OSL or the GPL.
	26
	27	----------------------------------------------------------------------
	28
	29	To-do list:
	30	* VT6421 PATA support
	31
	32	*/
	33
	34	#include <linux/kernel.h>
	35	#include <linux/module.h>
	36	#include <linux/pci.h>
	37	#include <linux/init.h>
	38	#include <linux/blkdev.h>
	39	#include <linux/delay.h>
	40	#include "scsi.h"
	41	#include <scsi/scsi_host.h>
	42	#include <linux/libata.h>
	43	#include <asm/io.h>
	44
	45	#define DRV_NAME "sata_via"
	46	#define DRV_VERSION "1.1"
	47
	48	enum board_ids_enum {
	49	vt6420,
	50	vt6421,
	51	};
	52
	53	enum {
	54	SATA_CHAN_ENAB = 0x40, /* SATA channel enable */
	55	SATA_INT_GATE = 0x41, /* SATA interrupt gating */
	56	SATA_NATIVE_MODE = 0x42, /* Native mode enable */
	57	SATA_PATA_SHARING = 0x49, /* PATA/SATA sharing func ctrl */
	58
	59	PORT0 = (1 << 1),
	60	PORT1 = (1 << 0),
	61	ALL_PORTS = PORT0 \| PORT1,
	62	N_PORTS = 2,
	63
	64	NATIVE_MODE_ALL = (1 << 7) \| (1 << 6) \| (1 << 5) \| (1 << 4),
65
66	SATA_EXT_PHY = (1 << 6), /* 0==use PATA, 1==ext phy */
67	SATA_2DEV = (1 << 5), /* SATA is master/slave */
68	};
69
70	static int svia_init_one (struct pci_dev pdev, const struct pci_device_id ent);
71	static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg);
72	static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
73
74	static struct pci_device_id svia_pci_tbl[] = {
75	{ 0x1106, 0x3149, PCI_ANY_ID, PCI_ANY_ID, 0, 0, vt6420 },
76	{ 0x1106, 0x3249, PCI_ANY_ID, PCI_ANY_ID, 0, 0, vt6421 },
77
78	{ } /* terminate list */
79	};
80
81	static struct pci_driver svia_pci_driver = {
82	.name = DRV_NAME,
83	.id_table = svia_pci_tbl,
84	.probe = svia_init_one,
85	.remove = ata_pci_remove_one,
86	};
87
88	static Scsi_Host_Template svia_sht = {
89	.module = THIS_MODULE,
90	.name = DRV_NAME,
91	.ioctl = ata_scsi_ioctl,
92	.queuecommand = ata_scsi_queuecmd,
93	.eh_strategy_handler = ata_scsi_error,
94	.can_queue = ATA_DEF_QUEUE,
95	.this_id = ATA_SHT_THIS_ID,
96	.sg_tablesize = LIBATA_MAX_PRD,
97	.max_sectors = ATA_MAX_SECTORS,
98	.cmd_per_lun = ATA_SHT_CMD_PER_LUN,
99	.emulated = ATA_SHT_EMULATED,
100	.use_clustering = ATA_SHT_USE_CLUSTERING,
101	.proc_name = DRV_NAME,
102	.dma_boundary = ATA_DMA_BOUNDARY,
103	.slave_configure = ata_scsi_slave_config,
104	.bios_param = ata_std_bios_param,
105	.ordered_flush = 1,
106	};
107
108	static struct ata_port_operations svia_sata_ops = {
109	.port_disable = ata_port_disable,
110
111	.tf_load = ata_tf_load,
112	.tf_read = ata_tf_read,
113	.check_status = ata_check_status,
114	.exec_command = ata_exec_command,
115	.dev_select = ata_std_dev_select,
116
117	.phy_reset = sata_phy_reset,
118
119	.bmdma_setup = ata_bmdma_setup,
120	.bmdma_start = ata_bmdma_start,
121	.bmdma_stop = ata_bmdma_stop,
122	.bmdma_status = ata_bmdma_status,
123
124	.qc_prep = ata_qc_prep,
125	.qc_issue = ata_qc_issue_prot,
126
127	.eng_timeout = ata_eng_timeout,
128
129	.irq_handler = ata_interrupt,
130	.irq_clear = ata_bmdma_irq_clear,
131
132	.scr_read = svia_scr_read,
133	.scr_write = svia_scr_write,
134
135	.port_start = ata_port_start,
136	.port_stop = ata_port_stop,
aa8f0dc6	137	.host_stop = ata_host_stop,
1da177e4 LT	138	};
	139
	140	static struct ata_port_info svia_port_info = {
	141	.sht = &svia_sht,
	142	.host_flags = ATA_FLAG_SATA \| ATA_FLAG_SRST \| ATA_FLAG_NO_LEGACY,
	143	.pio_mask = 0x1f,
	144	.mwdma_mask = 0x07,
	145	.udma_mask = 0x7f,
	146	.port_ops = &svia_sata_ops,
	147	};
	148
	149	MODULE_AUTHOR("Jeff Garzik");
	150	MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
	151	MODULE_LICENSE("GPL");
	152	MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
	153	MODULE_VERSION(DRV_VERSION);
	154
	155	static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
	156	{
	157	if (sc_reg > SCR_CONTROL)
	158	return 0xffffffffU;
	159	return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
	160	}
	161
	162	static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
	163	{
	164	if (sc_reg > SCR_CONTROL)
	165	return;
	166	outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
	167	}
	168
	169	static const unsigned int svia_bar_sizes[] = {
	170	8, 4, 8, 4, 16, 256
	171	};
	172
	173	static const unsigned int vt6421_bar_sizes[] = {
	174	16, 16, 16, 16, 32, 128
	175	};
	176
	177	static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
	178	{
	179	return addr + (port * 128);
	180	}
	181
	182	static unsigned long vt6421_scr_addr(unsigned long addr, unsigned int port)
	183	{
	184	return addr + (port * 64);
	185	}
	186
	187	static void vt6421_init_addrs(struct ata_probe_ent *probe_ent,
	188	struct pci_dev *pdev,
	189	unsigned int port)
	190	{
	191	unsigned long reg_addr = pci_resource_start(pdev, port);
	192	unsigned long bmdma_addr = pci_resource_start(pdev, 4) + (port * 8);
	193	unsigned long scr_addr;
	194
	195	probe_ent->port[port].cmd_addr = reg_addr;
	196	probe_ent->port[port].altstatus_addr =
	197	probe_ent->port[port].ctl_addr = (reg_addr + 8) \| ATA_PCI_CTL_OFS;
	198	probe_ent->port[port].bmdma_addr = bmdma_addr;
	199
	200	scr_addr = vt6421_scr_addr(pci_resource_start(pdev, 5), port);
	201	probe_ent->port[port].scr_addr = scr_addr;
202
203	ata_std_ports(&probe_ent->port[port]);
204	}
205
206	static struct ata_probe_ent vt6420_init_probe_ent(struct pci_dev pdev)
207	{
208	struct ata_probe_ent *probe_ent;
209	struct ata_port_info *ppi = &svia_port_info;
210
211	probe_ent = ata_pci_init_native_mode(pdev, &ppi);
212	if (!probe_ent)
213	return NULL;
214
215	probe_ent->port[0].scr_addr =
216	svia_scr_addr(pci_resource_start(pdev, 5), 0);
217	probe_ent->port[1].scr_addr =
218	svia_scr_addr(pci_resource_start(pdev, 5), 1);
219
220	return probe_ent;
221	}
222
223	static struct ata_probe_ent vt6421_init_probe_ent(struct pci_dev pdev)
224	{
225	struct ata_probe_ent *probe_ent;
226	unsigned int i;
227
228	probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
229	if (!probe_ent)
230	return NULL;
231
232	memset(probe_ent, 0, sizeof(*probe_ent));
233	probe_ent->dev = pci_dev_to_dev(pdev);
234	INIT_LIST_HEAD(&probe_ent->node);
235
236	probe_ent->sht = &svia_sht;
237	probe_ent->host_flags = ATA_FLAG_SATA \| ATA_FLAG_SATA_RESET \|
238	ATA_FLAG_NO_LEGACY;
239	probe_ent->port_ops = &svia_sata_ops;
240	probe_ent->n_ports = N_PORTS;
241	probe_ent->irq = pdev->irq;
242	probe_ent->irq_flags = SA_SHIRQ;
243	probe_ent->pio_mask = 0x1f;
244	probe_ent->mwdma_mask = 0x07;
245	probe_ent->udma_mask = 0x7f;
246
247	for (i = 0; i < N_PORTS; i++)
248	vt6421_init_addrs(probe_ent, pdev, i);
249
250	return probe_ent;
251	}
252
253	static void svia_configure(struct pci_dev *pdev)
254	{
255	u8 tmp8;
256
257	pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
258	printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
259	pci_name(pdev),
260	(int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
261
262	/* make sure SATA channels are enabled */
263	pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
264	if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
265	printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
266	pci_name(pdev), (int) tmp8);
267	tmp8 \|= ALL_PORTS;
268	pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
269	}
270
271	/* make sure interrupts for each channel sent to us */
272	pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
273	if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
274	printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
275	pci_name(pdev), (int) tmp8);
276	tmp8 \|= ALL_PORTS;
277	pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
278	}
279
280	/* make sure native mode is enabled */
281	pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
282	if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
283	printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
284	pci_name(pdev), (int) tmp8);
285	tmp8 \|= NATIVE_MODE_ALL;
286	pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
287	}
288	}
289
290	static int svia_init_one (struct pci_dev pdev, const struct pci_device_id ent)
291	{
292	static int printed_version;
293	unsigned int i;
294	int rc;
295	struct ata_probe_ent *probe_ent;
296	int board_id = (int) ent->driver_data;
297	const int *bar_sizes;
298	int pci_dev_busy = 0;
299	u8 tmp8;
300
301	if (!printed_version++)
302	printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
303
304	rc = pci_enable_device(pdev);
305	if (rc)
306	return rc;
307
308	rc = pci_request_regions(pdev, DRV_NAME);
309	if (rc) {
310	pci_dev_busy = 1;
311	goto err_out;
312	}
313
314	if (board_id == vt6420) {
315	pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
316	if (tmp8 & SATA_2DEV) {
317	printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
318	pci_name(pdev), (int) tmp8);
319	rc = -EIO;
320	goto err_out_regions;
321	}
322
323	bar_sizes = &svia_bar_sizes[0];
324	} else {
325	bar_sizes = &vt6421_bar_sizes[0];
326	}
327
328	for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
329	if ((pci_resource_start(pdev, i) == 0) \|\|
330	(pci_resource_len(pdev, i) < bar_sizes[i])) {
331	printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
332	pci_name(pdev), i,
333	pci_resource_start(pdev, i),
334	pci_resource_len(pdev, i));
335	rc = -ENODEV;
336	goto err_out_regions;
337	}
338
339	rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
340	if (rc)
341	goto err_out_regions;
342	rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
343	if (rc)
344	goto err_out_regions;
345
346	if (board_id == vt6420)
347	probe_ent = vt6420_init_probe_ent(pdev);
348	else
349	probe_ent = vt6421_init_probe_ent(pdev);
350
351	if (!probe_ent) {
352	printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
353	pci_name(pdev));
354	rc = -ENOMEM;
355	goto err_out_regions;
356	}
357
358	svia_configure(pdev);
359
360	pci_set_master(pdev);
361
362	/* FIXME: check ata_device_add return value */
363	ata_device_add(probe_ent);
364	kfree(probe_ent);
365
366	return 0;
367
368	err_out_regions:
369	pci_release_regions(pdev);
370	err_out:
371	if (!pci_dev_busy)
372	pci_disable_device(pdev);
373	return rc;
374	}
375
376	static int __init svia_init(void)
377	{
378	return pci_module_init(&svia_pci_driver);
379	}
380
381	static void __exit svia_exit(void)
382	{
383	pci_unregister_driver(&svia_pci_driver);
384	}
385
386	module_init(svia_init);
387	module_exit(svia_exit);
388