2 sata_via.c - VIA Serial ATA controllers
4 Copyright 2003-2004 Red Hat, Inc. All rights reserved.
5 Copyright 2003-2004 Jeff Garzik
7 The contents of this file are subject to the Open
8 Software License version 1.1 that can be found at
9 http://www.opensource.org/licenses/osl-1.1.txt and is included herein
12 Alternatively, the contents of this file may be used under the terms
13 of the GNU General Public License version 2 (the "GPL") as distributed
14 in the kernel source COPYING file, in which case the provisions of
15 the GPL are applicable instead of the above. If you wish to allow
16 the use of your version of this file only under the terms of the
17 GPL and not to allow others to use your version of this file under
18 the OSL, indicate your decision by deleting the provisions above and
19 replace them with the notice and other provisions required by the GPL.
20 If you do not delete the provisions above, a recipient may use your
21 version of this file under either the OSL or the GPL.
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/pci.h>
28 #include <linux/init.h>
29 #include <linux/blkdev.h>
30 #include <linux/delay.h>
33 #include <linux/libata.h>
36 #define DRV_NAME "sata_via"
37 #define DRV_VERSION "0.20"
42 SATA_CHAN_ENAB = 0x40, /* SATA channel enable */
43 SATA_INT_GATE = 0x41, /* SATA interrupt gating */
44 SATA_NATIVE_MODE = 0x42, /* Native mode enable */
45 SATA_PATA_SHARING = 0x49, /* PATA/SATA sharing func ctrl */
50 ENAB_ALL = PORT0 | PORT1,
52 INT_GATE_ALL = PORT0 | PORT1,
54 NATIVE_MODE_ALL = (1 << 7) | (1 << 6) | (1 << 5) | (1 << 4),
56 SATA_EXT_PHY = (1 << 6), /* 0==use PATA, 1==ext phy */
57 SATA_2DEV = (1 << 5), /* SATA is master/slave */
60 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
61 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg);
62 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
64 static struct pci_device_id svia_pci_tbl[] = {
65 { 0x1106, 0x3149, PCI_ANY_ID, PCI_ANY_ID, 0, 0, via_sata },
67 { } /* terminate list */
70 static struct pci_driver svia_pci_driver = {
72 .id_table = svia_pci_tbl,
73 .probe = svia_init_one,
74 .remove = ata_pci_remove_one,
77 static Scsi_Host_Template svia_sht = {
78 .module = THIS_MODULE,
80 .queuecommand = ata_scsi_queuecmd,
81 .eh_strategy_handler = ata_scsi_error,
82 .can_queue = ATA_DEF_QUEUE,
83 .this_id = ATA_SHT_THIS_ID,
84 .sg_tablesize = LIBATA_MAX_PRD,
85 .max_sectors = ATA_MAX_SECTORS,
86 .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
87 .emulated = ATA_SHT_EMULATED,
88 .use_clustering = ATA_SHT_USE_CLUSTERING,
89 .proc_name = DRV_NAME,
90 .dma_boundary = ATA_DMA_BOUNDARY,
91 .slave_configure = ata_scsi_slave_config,
92 .bios_param = ata_std_bios_param,
95 static struct ata_port_operations svia_sata_ops = {
96 .port_disable = ata_port_disable,
98 .tf_load = ata_tf_load_pio,
99 .tf_read = ata_tf_read_pio,
100 .check_status = ata_check_status_pio,
101 .exec_command = ata_exec_command_pio,
103 .phy_reset = sata_phy_reset,
105 .bmdma_start = ata_bmdma_start_pio,
106 .fill_sg = ata_fill_sg,
107 .eng_timeout = ata_eng_timeout,
109 .irq_handler = ata_interrupt,
111 .scr_read = svia_scr_read,
112 .scr_write = svia_scr_write,
114 .port_start = ata_port_start,
115 .port_stop = ata_port_stop,
118 MODULE_AUTHOR("Jeff Garzik");
119 MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
120 MODULE_LICENSE("GPL");
121 MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
123 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
125 if (sc_reg > SCR_CONTROL)
127 return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
130 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
132 if (sc_reg > SCR_CONTROL)
134 outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
137 static const unsigned int svia_bar_sizes[] = {
141 static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
143 return addr + (port * 128);
157 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
159 static int printed_version;
162 struct ata_probe_ent *probe_ent;
165 if (!printed_version++)
166 printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
168 rc = pci_enable_device(pdev);
172 rc = pci_request_regions(pdev, DRV_NAME);
176 pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
177 if (tmp8 & SATA_2DEV) {
178 printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
179 pci_name(pdev), (int) tmp8);
181 goto err_out_regions;
184 for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
185 if ((pci_resource_start(pdev, i) == 0) ||
186 (pci_resource_len(pdev, i) < svia_bar_sizes[i])) {
187 printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
189 pci_resource_start(pdev, i),
190 pci_resource_len(pdev, i));
192 goto err_out_regions;
195 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
197 goto err_out_regions;
198 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
200 goto err_out_regions;
202 probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
204 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
207 goto err_out_regions;
209 memset(probe_ent, 0, sizeof(*probe_ent));
210 INIT_LIST_HEAD(&probe_ent->node);
211 probe_ent->pdev = pdev;
212 probe_ent->sht = &svia_sht;
213 probe_ent->host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST |
215 probe_ent->port_ops = &svia_sata_ops;
216 probe_ent->n_ports = 2;
217 probe_ent->irq = pdev->irq;
218 probe_ent->irq_flags = SA_SHIRQ;
219 probe_ent->pio_mask = 0x1f;
220 probe_ent->udma_mask = 0x7f;
222 probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
223 ata_std_ports(&probe_ent->port[0]);
224 probe_ent->port[0].altstatus_addr =
225 probe_ent->port[0].ctl_addr =
226 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
227 probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
228 probe_ent->port[0].scr_addr =
229 svia_scr_addr(pci_resource_start(pdev, 5), 0);
231 probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
232 ata_std_ports(&probe_ent->port[1]);
233 probe_ent->port[1].altstatus_addr =
234 probe_ent->port[1].ctl_addr =
235 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
236 probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
237 probe_ent->port[1].scr_addr =
238 svia_scr_addr(pci_resource_start(pdev, 5), 1);
240 pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
241 printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
243 (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
245 /* make sure SATA channels are enabled */
246 pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
247 if ((tmp8 & ENAB_ALL) != ENAB_ALL) {
248 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
249 pci_name(pdev), (int) tmp8);
251 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
254 /* make sure interrupts for each channel sent to us */
255 pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
256 if ((tmp8 & INT_GATE_ALL) != INT_GATE_ALL) {
257 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
258 pci_name(pdev), (int) tmp8);
259 tmp8 |= INT_GATE_ALL;
260 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
263 /* make sure native mode is enabled */
264 pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
265 if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
266 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
267 pci_name(pdev), (int) tmp8);
268 tmp8 |= NATIVE_MODE_ALL;
269 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
272 pci_set_master(pdev);
274 /* FIXME: check ata_device_add return value */
275 ata_device_add(probe_ent);
281 pci_release_regions(pdev);
283 pci_disable_device(pdev);
296 static int __init svia_init(void)
298 return pci_module_init(&svia_pci_driver);
308 static void __exit svia_exit(void)
310 pci_unregister_driver(&svia_pci_driver);
313 module_init(svia_init);
314 module_exit(svia_exit);