2 sata_via.c - VIA Serial ATA controllers
4 Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 Please ALWAYS copy linux-ide@vger.kernel.org
8 Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 Copyright 2003-2004 Jeff Garzik
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
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.
27 ----------------------------------------------------------------------
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>
41 #include <scsi/scsi_host.h>
42 #include <linux/libata.h>
45 #define DRV_NAME "sata_via"
46 #define DRV_VERSION "1.1"
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 */
61 ALL_PORTS = PORT0 | PORT1,
64 NATIVE_MODE_ALL = (1 << 7) | (1 << 6) | (1 << 5) | (1 << 4),
66 SATA_EXT_PHY = (1 << 6), /* 0==use PATA, 1==ext phy */
67 SATA_2DEV = (1 << 5), /* SATA is master/slave */
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);
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 },
78 { } /* terminate list */
81 static struct pci_driver svia_pci_driver = {
83 .id_table = svia_pci_tbl,
84 .probe = svia_init_one,
85 .remove = ata_pci_remove_one,
88 static Scsi_Host_Template svia_sht = {
89 .module = THIS_MODULE,
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,
107 static struct ata_port_operations svia_sata_ops = {
108 .port_disable = ata_port_disable,
110 .tf_load = ata_tf_load,
111 .tf_read = ata_tf_read,
112 .check_status = ata_check_status,
113 .exec_command = ata_exec_command,
114 .dev_select = ata_std_dev_select,
116 .phy_reset = sata_phy_reset,
118 .bmdma_setup = ata_bmdma_setup,
119 .bmdma_start = ata_bmdma_start,
120 .bmdma_stop = ata_bmdma_stop,
121 .bmdma_status = ata_bmdma_status,
123 .qc_prep = ata_qc_prep,
124 .qc_issue = ata_qc_issue_prot,
126 .eng_timeout = ata_eng_timeout,
128 .irq_handler = ata_interrupt,
129 .irq_clear = ata_bmdma_irq_clear,
131 .scr_read = svia_scr_read,
132 .scr_write = svia_scr_write,
134 .port_start = ata_port_start,
135 .port_stop = ata_port_stop,
138 static struct ata_port_info svia_port_info = {
140 .host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST | ATA_FLAG_NO_LEGACY,
144 .port_ops = &svia_sata_ops,
147 MODULE_AUTHOR("Jeff Garzik");
148 MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
149 MODULE_LICENSE("GPL");
150 MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
151 MODULE_VERSION(DRV_VERSION);
153 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
155 if (sc_reg > SCR_CONTROL)
157 return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
160 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
162 if (sc_reg > SCR_CONTROL)
164 outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
167 static const unsigned int svia_bar_sizes[] = {
171 static const unsigned int vt6421_bar_sizes[] = {
172 16, 16, 16, 16, 32, 128
175 static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
177 return addr + (port * 128);
180 static unsigned long vt6421_scr_addr(unsigned long addr, unsigned int port)
182 return addr + (port * 64);
185 static void vt6421_init_addrs(struct ata_probe_ent *probe_ent,
186 struct pci_dev *pdev,
189 unsigned long reg_addr = pci_resource_start(pdev, port);
190 unsigned long bmdma_addr = pci_resource_start(pdev, 4) + (port * 8);
191 unsigned long scr_addr;
193 probe_ent->port[port].cmd_addr = reg_addr;
194 probe_ent->port[port].altstatus_addr =
195 probe_ent->port[port].ctl_addr = (reg_addr + 8) | ATA_PCI_CTL_OFS;
196 probe_ent->port[port].bmdma_addr = bmdma_addr;
198 scr_addr = vt6421_scr_addr(pci_resource_start(pdev, 5), port);
199 probe_ent->port[port].scr_addr = scr_addr;
201 ata_std_ports(&probe_ent->port[port]);
204 static struct ata_probe_ent *vt6420_init_probe_ent(struct pci_dev *pdev)
206 struct ata_probe_ent *probe_ent;
207 struct ata_port_info *ppi = &svia_port_info;
209 probe_ent = ata_pci_init_native_mode(pdev, &ppi);
213 probe_ent->port[0].scr_addr =
214 svia_scr_addr(pci_resource_start(pdev, 5), 0);
215 probe_ent->port[1].scr_addr =
216 svia_scr_addr(pci_resource_start(pdev, 5), 1);
221 static struct ata_probe_ent *vt6421_init_probe_ent(struct pci_dev *pdev)
223 struct ata_probe_ent *probe_ent;
226 probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
230 memset(probe_ent, 0, sizeof(*probe_ent));
231 probe_ent->dev = pci_dev_to_dev(pdev);
232 INIT_LIST_HEAD(&probe_ent->node);
234 probe_ent->sht = &svia_sht;
235 probe_ent->host_flags = ATA_FLAG_SATA | ATA_FLAG_SATA_RESET |
237 probe_ent->port_ops = &svia_sata_ops;
238 probe_ent->n_ports = N_PORTS;
239 probe_ent->irq = pdev->irq;
240 probe_ent->irq_flags = SA_SHIRQ;
241 probe_ent->pio_mask = 0x1f;
242 probe_ent->mwdma_mask = 0x07;
243 probe_ent->udma_mask = 0x7f;
245 for (i = 0; i < N_PORTS; i++)
246 vt6421_init_addrs(probe_ent, pdev, i);
251 static void svia_configure(struct pci_dev *pdev)
255 pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
256 printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
258 (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
260 /* make sure SATA channels are enabled */
261 pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
262 if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
263 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
264 pci_name(pdev), (int) tmp8);
266 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
269 /* make sure interrupts for each channel sent to us */
270 pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
271 if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
272 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
273 pci_name(pdev), (int) tmp8);
275 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
278 /* make sure native mode is enabled */
279 pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
280 if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
281 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
282 pci_name(pdev), (int) tmp8);
283 tmp8 |= NATIVE_MODE_ALL;
284 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
288 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
290 static int printed_version;
293 struct ata_probe_ent *probe_ent;
294 int board_id = (int) ent->driver_data;
295 const int *bar_sizes;
296 int pci_dev_busy = 0;
299 if (!printed_version++)
300 printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
302 rc = pci_enable_device(pdev);
306 rc = pci_request_regions(pdev, DRV_NAME);
312 if (board_id == vt6420) {
313 pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
314 if (tmp8 & SATA_2DEV) {
315 printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
316 pci_name(pdev), (int) tmp8);
318 goto err_out_regions;
321 bar_sizes = &svia_bar_sizes[0];
323 bar_sizes = &vt6421_bar_sizes[0];
326 for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
327 if ((pci_resource_start(pdev, i) == 0) ||
328 (pci_resource_len(pdev, i) < bar_sizes[i])) {
329 printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
331 pci_resource_start(pdev, i),
332 pci_resource_len(pdev, i));
334 goto err_out_regions;
337 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
339 goto err_out_regions;
340 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
342 goto err_out_regions;
344 if (board_id == vt6420)
345 probe_ent = vt6420_init_probe_ent(pdev);
347 probe_ent = vt6421_init_probe_ent(pdev);
350 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
353 goto err_out_regions;
356 svia_configure(pdev);
358 pci_set_master(pdev);
360 /* FIXME: check ata_device_add return value */
361 ata_device_add(probe_ent);
367 pci_release_regions(pdev);
370 pci_disable_device(pdev);
374 static int __init svia_init(void)
376 return pci_module_init(&svia_pci_driver);
379 static void __exit svia_exit(void)
381 pci_unregister_driver(&svia_pci_driver);
384 module_init(svia_init);
385 module_exit(svia_exit);