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
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
30 * Hardware documentation available under NDA.
34 * - VT6421 PATA support
38 #include <linux/kernel.h>
39 #include <linux/module.h>
40 #include <linux/pci.h>
41 #include <linux/init.h>
42 #include <linux/blkdev.h>
43 #include <linux/delay.h>
44 #include <linux/device.h>
45 #include <scsi/scsi_host.h>
46 #include <linux/libata.h>
48 #define DRV_NAME "sata_via"
49 #define DRV_VERSION "2.3"
57 SATA_CHAN_ENAB
= 0x40, /* SATA channel enable */
58 SATA_INT_GATE
= 0x41, /* SATA interrupt gating */
59 SATA_NATIVE_MODE
= 0x42, /* Native mode enable */
60 SATA_PATA_SHARING
= 0x49, /* PATA/SATA sharing func ctrl */
61 PATA_UDMA_TIMING
= 0xB3, /* PATA timing for DMA/ cable detect */
62 PATA_PIO_TIMING
= 0xAB, /* PATA timing register */
66 ALL_PORTS
= PORT0
| PORT1
,
68 NATIVE_MODE_ALL
= (1 << 7) | (1 << 6) | (1 << 5) | (1 << 4),
70 SATA_EXT_PHY
= (1 << 6), /* 0==use PATA, 1==ext phy */
71 SATA_2DEV
= (1 << 5), /* SATA is master/slave */
74 static int svia_init_one (struct pci_dev
*pdev
, const struct pci_device_id
*ent
);
75 static int svia_scr_read(struct ata_port
*ap
, unsigned int sc_reg
, u32
*val
);
76 static int svia_scr_write(struct ata_port
*ap
, unsigned int sc_reg
, u32 val
);
77 static void svia_noop_freeze(struct ata_port
*ap
);
78 static void vt6420_error_handler(struct ata_port
*ap
);
79 static int vt6421_pata_cable_detect(struct ata_port
*ap
);
80 static void vt6421_set_pio_mode(struct ata_port
*ap
, struct ata_device
*adev
);
81 static void vt6421_set_dma_mode(struct ata_port
*ap
, struct ata_device
*adev
);
83 static const struct pci_device_id svia_pci_tbl
[] = {
84 { PCI_VDEVICE(VIA
, 0x5337), vt6420
},
85 { PCI_VDEVICE(VIA
, 0x0591), vt6420
},
86 { PCI_VDEVICE(VIA
, 0x3149), vt6420
},
87 { PCI_VDEVICE(VIA
, 0x3249), vt6421
},
88 { PCI_VDEVICE(VIA
, 0x5287), vt6420
},
89 { PCI_VDEVICE(VIA
, 0x5372), vt6420
},
90 { PCI_VDEVICE(VIA
, 0x7372), vt6420
},
92 { } /* terminate list */
95 static struct pci_driver svia_pci_driver
= {
97 .id_table
= svia_pci_tbl
,
98 .probe
= svia_init_one
,
100 .suspend
= ata_pci_device_suspend
,
101 .resume
= ata_pci_device_resume
,
103 .remove
= ata_pci_remove_one
,
106 static struct scsi_host_template svia_sht
= {
107 .module
= THIS_MODULE
,
109 .ioctl
= ata_scsi_ioctl
,
110 .queuecommand
= ata_scsi_queuecmd
,
111 .can_queue
= ATA_DEF_QUEUE
,
112 .this_id
= ATA_SHT_THIS_ID
,
113 .sg_tablesize
= LIBATA_MAX_PRD
,
114 .cmd_per_lun
= ATA_SHT_CMD_PER_LUN
,
115 .emulated
= ATA_SHT_EMULATED
,
116 .use_clustering
= ATA_SHT_USE_CLUSTERING
,
117 .proc_name
= DRV_NAME
,
118 .dma_boundary
= ATA_DMA_BOUNDARY
,
119 .slave_configure
= ata_scsi_slave_config
,
120 .slave_destroy
= ata_scsi_slave_destroy
,
121 .bios_param
= ata_std_bios_param
,
124 static const struct ata_port_operations vt6420_sata_ops
= {
125 .port_disable
= ata_port_disable
,
127 .tf_load
= ata_tf_load
,
128 .tf_read
= ata_tf_read
,
129 .check_status
= ata_check_status
,
130 .exec_command
= ata_exec_command
,
131 .dev_select
= ata_std_dev_select
,
133 .bmdma_setup
= ata_bmdma_setup
,
134 .bmdma_start
= ata_bmdma_start
,
135 .bmdma_stop
= ata_bmdma_stop
,
136 .bmdma_status
= ata_bmdma_status
,
138 .qc_prep
= ata_qc_prep
,
139 .qc_issue
= ata_qc_issue_prot
,
140 .data_xfer
= ata_data_xfer
,
142 .freeze
= svia_noop_freeze
,
143 .thaw
= ata_bmdma_thaw
,
144 .error_handler
= vt6420_error_handler
,
145 .post_internal_cmd
= ata_bmdma_post_internal_cmd
,
147 .irq_clear
= ata_bmdma_irq_clear
,
148 .irq_on
= ata_irq_on
,
150 .port_start
= ata_port_start
,
153 static const struct ata_port_operations vt6421_pata_ops
= {
154 .port_disable
= ata_port_disable
,
156 .set_piomode
= vt6421_set_pio_mode
,
157 .set_dmamode
= vt6421_set_dma_mode
,
159 .tf_load
= ata_tf_load
,
160 .tf_read
= ata_tf_read
,
161 .check_status
= ata_check_status
,
162 .exec_command
= ata_exec_command
,
163 .dev_select
= ata_std_dev_select
,
165 .bmdma_setup
= ata_bmdma_setup
,
166 .bmdma_start
= ata_bmdma_start
,
167 .bmdma_stop
= ata_bmdma_stop
,
168 .bmdma_status
= ata_bmdma_status
,
170 .qc_prep
= ata_qc_prep
,
171 .qc_issue
= ata_qc_issue_prot
,
172 .data_xfer
= ata_data_xfer
,
174 .freeze
= ata_bmdma_freeze
,
175 .thaw
= ata_bmdma_thaw
,
176 .error_handler
= ata_bmdma_error_handler
,
177 .post_internal_cmd
= ata_bmdma_post_internal_cmd
,
178 .cable_detect
= vt6421_pata_cable_detect
,
180 .irq_clear
= ata_bmdma_irq_clear
,
181 .irq_on
= ata_irq_on
,
183 .port_start
= ata_port_start
,
186 static const struct ata_port_operations vt6421_sata_ops
= {
187 .port_disable
= ata_port_disable
,
189 .tf_load
= ata_tf_load
,
190 .tf_read
= ata_tf_read
,
191 .check_status
= ata_check_status
,
192 .exec_command
= ata_exec_command
,
193 .dev_select
= ata_std_dev_select
,
195 .bmdma_setup
= ata_bmdma_setup
,
196 .bmdma_start
= ata_bmdma_start
,
197 .bmdma_stop
= ata_bmdma_stop
,
198 .bmdma_status
= ata_bmdma_status
,
200 .qc_prep
= ata_qc_prep
,
201 .qc_issue
= ata_qc_issue_prot
,
202 .data_xfer
= ata_data_xfer
,
204 .freeze
= ata_bmdma_freeze
,
205 .thaw
= ata_bmdma_thaw
,
206 .error_handler
= ata_bmdma_error_handler
,
207 .post_internal_cmd
= ata_bmdma_post_internal_cmd
,
208 .cable_detect
= ata_cable_sata
,
210 .irq_clear
= ata_bmdma_irq_clear
,
211 .irq_on
= ata_irq_on
,
213 .scr_read
= svia_scr_read
,
214 .scr_write
= svia_scr_write
,
216 .port_start
= ata_port_start
,
219 static const struct ata_port_info vt6420_port_info
= {
220 .flags
= ATA_FLAG_SATA
| ATA_FLAG_NO_LEGACY
,
223 .udma_mask
= ATA_UDMA6
,
224 .port_ops
= &vt6420_sata_ops
,
227 static struct ata_port_info vt6421_sport_info
= {
228 .flags
= ATA_FLAG_SATA
| ATA_FLAG_NO_LEGACY
,
231 .udma_mask
= ATA_UDMA6
,
232 .port_ops
= &vt6421_sata_ops
,
235 static struct ata_port_info vt6421_pport_info
= {
236 .flags
= ATA_FLAG_SLAVE_POSS
| ATA_FLAG_NO_LEGACY
,
239 .udma_mask
= ATA_UDMA6
,
240 .port_ops
= &vt6421_pata_ops
,
243 MODULE_AUTHOR("Jeff Garzik");
244 MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
245 MODULE_LICENSE("GPL");
246 MODULE_DEVICE_TABLE(pci
, svia_pci_tbl
);
247 MODULE_VERSION(DRV_VERSION
);
249 static int svia_scr_read(struct ata_port
*ap
, unsigned int sc_reg
, u32
*val
)
251 if (sc_reg
> SCR_CONTROL
)
253 *val
= ioread32(ap
->ioaddr
.scr_addr
+ (4 * sc_reg
));
257 static int svia_scr_write(struct ata_port
*ap
, unsigned int sc_reg
, u32 val
)
259 if (sc_reg
> SCR_CONTROL
)
261 iowrite32(val
, ap
->ioaddr
.scr_addr
+ (4 * sc_reg
));
265 static void svia_noop_freeze(struct ata_port
*ap
)
267 /* Some VIA controllers choke if ATA_NIEN is manipulated in
268 * certain way. Leave it alone and just clear pending IRQ.
271 ata_bmdma_irq_clear(ap
);
275 * vt6420_prereset - prereset for vt6420
276 * @link: target ATA link
277 * @deadline: deadline jiffies for the operation
279 * SCR registers on vt6420 are pieces of shit and may hang the
280 * whole machine completely if accessed with the wrong timing.
281 * To avoid such catastrophe, vt6420 doesn't provide generic SCR
282 * access operations, but uses SStatus and SControl only during
283 * boot probing in controlled way.
285 * As the old (pre EH update) probing code is proven to work, we
286 * strictly follow the access pattern.
289 * Kernel thread context (may sleep)
292 * 0 on success, -errno otherwise.
294 static int vt6420_prereset(struct ata_link
*link
, unsigned long deadline
)
296 struct ata_port
*ap
= link
->ap
;
297 struct ata_eh_context
*ehc
= &ap
->link
.eh_context
;
298 unsigned long timeout
= jiffies
+ (HZ
* 5);
299 u32 sstatus
, scontrol
;
302 /* don't do any SCR stuff if we're not loading */
303 if (!(ap
->pflags
& ATA_PFLAG_LOADING
))
306 /* Resume phy. This is the old SATA resume sequence */
307 svia_scr_write(ap
, SCR_CONTROL
, 0x300);
308 svia_scr_read(ap
, SCR_CONTROL
, &scontrol
); /* flush */
310 /* wait for phy to become ready, if necessary */
313 svia_scr_read(ap
, SCR_STATUS
, &sstatus
);
314 if ((sstatus
& 0xf) != 1)
316 } while (time_before(jiffies
, timeout
));
318 /* open code sata_print_link_status() */
319 svia_scr_read(ap
, SCR_STATUS
, &sstatus
);
320 svia_scr_read(ap
, SCR_CONTROL
, &scontrol
);
322 online
= (sstatus
& 0xf) == 0x3;
324 ata_port_printk(ap
, KERN_INFO
,
325 "SATA link %s 1.5 Gbps (SStatus %X SControl %X)\n",
326 online
? "up" : "down", sstatus
, scontrol
);
328 /* SStatus is read one more time */
329 svia_scr_read(ap
, SCR_STATUS
, &sstatus
);
332 /* tell EH to bail */
333 ehc
->i
.action
&= ~ATA_EH_RESET_MASK
;
339 ata_wait_ready(ap
, deadline
);
344 static void vt6420_error_handler(struct ata_port
*ap
)
346 return ata_bmdma_drive_eh(ap
, vt6420_prereset
, ata_std_softreset
,
347 NULL
, ata_std_postreset
);
350 static int vt6421_pata_cable_detect(struct ata_port
*ap
)
352 struct pci_dev
*pdev
= to_pci_dev(ap
->host
->dev
);
355 pci_read_config_byte(pdev
, PATA_UDMA_TIMING
, &tmp
);
357 return ATA_CBL_PATA40
;
358 return ATA_CBL_PATA80
;
361 static void vt6421_set_pio_mode(struct ata_port
*ap
, struct ata_device
*adev
)
363 struct pci_dev
*pdev
= to_pci_dev(ap
->host
->dev
);
364 static const u8 pio_bits
[] = { 0xA8, 0x65, 0x65, 0x31, 0x20 };
365 pci_write_config_byte(pdev
, PATA_PIO_TIMING
, pio_bits
[adev
->pio_mode
- XFER_PIO_0
]);
368 static void vt6421_set_dma_mode(struct ata_port
*ap
, struct ata_device
*adev
)
370 struct pci_dev
*pdev
= to_pci_dev(ap
->host
->dev
);
371 static const u8 udma_bits
[] = { 0xEE, 0xE8, 0xE6, 0xE4, 0xE2, 0xE1, 0xE0, 0xE0 };
372 pci_write_config_byte(pdev
, PATA_UDMA_TIMING
, udma_bits
[adev
->dma_mode
- XFER_UDMA_0
]);
375 static const unsigned int svia_bar_sizes
[] = {
379 static const unsigned int vt6421_bar_sizes
[] = {
380 16, 16, 16, 16, 32, 128
383 static void __iomem
* svia_scr_addr(void __iomem
*addr
, unsigned int port
)
385 return addr
+ (port
* 128);
388 static void __iomem
* vt6421_scr_addr(void __iomem
*addr
, unsigned int port
)
390 return addr
+ (port
* 64);
393 static void vt6421_init_addrs(struct ata_port
*ap
)
395 void __iomem
* const * iomap
= ap
->host
->iomap
;
396 void __iomem
*reg_addr
= iomap
[ap
->port_no
];
397 void __iomem
*bmdma_addr
= iomap
[4] + (ap
->port_no
* 8);
398 struct ata_ioports
*ioaddr
= &ap
->ioaddr
;
400 ioaddr
->cmd_addr
= reg_addr
;
401 ioaddr
->altstatus_addr
=
402 ioaddr
->ctl_addr
= (void __iomem
*)
403 ((unsigned long)(reg_addr
+ 8) | ATA_PCI_CTL_OFS
);
404 ioaddr
->bmdma_addr
= bmdma_addr
;
405 ioaddr
->scr_addr
= vt6421_scr_addr(iomap
[5], ap
->port_no
);
407 ata_std_ports(ioaddr
);
410 static int vt6420_prepare_host(struct pci_dev
*pdev
, struct ata_host
**r_host
)
412 const struct ata_port_info
*ppi
[] = { &vt6420_port_info
, NULL
};
413 struct ata_host
*host
;
416 rc
= ata_pci_prepare_sff_host(pdev
, ppi
, &host
);
421 rc
= pcim_iomap_regions(pdev
, 1 << 5, DRV_NAME
);
423 dev_printk(KERN_ERR
, &pdev
->dev
, "failed to iomap PCI BAR 5\n");
427 host
->ports
[0]->ioaddr
.scr_addr
= svia_scr_addr(host
->iomap
[5], 0);
428 host
->ports
[1]->ioaddr
.scr_addr
= svia_scr_addr(host
->iomap
[5], 1);
433 static int vt6421_prepare_host(struct pci_dev
*pdev
, struct ata_host
**r_host
)
435 const struct ata_port_info
*ppi
[] =
436 { &vt6421_sport_info
, &vt6421_sport_info
, &vt6421_pport_info
};
437 struct ata_host
*host
;
440 *r_host
= host
= ata_host_alloc_pinfo(&pdev
->dev
, ppi
, ARRAY_SIZE(ppi
));
442 dev_printk(KERN_ERR
, &pdev
->dev
, "failed to allocate host\n");
446 rc
= pcim_iomap_regions(pdev
, 0x3f, DRV_NAME
);
448 dev_printk(KERN_ERR
, &pdev
->dev
, "failed to request/iomap "
449 "PCI BARs (errno=%d)\n", rc
);
452 host
->iomap
= pcim_iomap_table(pdev
);
454 for (i
= 0; i
< host
->n_ports
; i
++)
455 vt6421_init_addrs(host
->ports
[i
]);
457 rc
= pci_set_dma_mask(pdev
, ATA_DMA_MASK
);
460 rc
= pci_set_consistent_dma_mask(pdev
, ATA_DMA_MASK
);
467 static void svia_configure(struct pci_dev
*pdev
)
471 pci_read_config_byte(pdev
, PCI_INTERRUPT_LINE
, &tmp8
);
472 dev_printk(KERN_INFO
, &pdev
->dev
, "routed to hard irq line %d\n",
473 (int) (tmp8
& 0xf0) == 0xf0 ? 0 : tmp8
& 0x0f);
475 /* make sure SATA channels are enabled */
476 pci_read_config_byte(pdev
, SATA_CHAN_ENAB
, &tmp8
);
477 if ((tmp8
& ALL_PORTS
) != ALL_PORTS
) {
478 dev_printk(KERN_DEBUG
, &pdev
->dev
,
479 "enabling SATA channels (0x%x)\n",
482 pci_write_config_byte(pdev
, SATA_CHAN_ENAB
, tmp8
);
485 /* make sure interrupts for each channel sent to us */
486 pci_read_config_byte(pdev
, SATA_INT_GATE
, &tmp8
);
487 if ((tmp8
& ALL_PORTS
) != ALL_PORTS
) {
488 dev_printk(KERN_DEBUG
, &pdev
->dev
,
489 "enabling SATA channel interrupts (0x%x)\n",
492 pci_write_config_byte(pdev
, SATA_INT_GATE
, tmp8
);
495 /* make sure native mode is enabled */
496 pci_read_config_byte(pdev
, SATA_NATIVE_MODE
, &tmp8
);
497 if ((tmp8
& NATIVE_MODE_ALL
) != NATIVE_MODE_ALL
) {
498 dev_printk(KERN_DEBUG
, &pdev
->dev
,
499 "enabling SATA channel native mode (0x%x)\n",
501 tmp8
|= NATIVE_MODE_ALL
;
502 pci_write_config_byte(pdev
, SATA_NATIVE_MODE
, tmp8
);
506 static int svia_init_one (struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
508 static int printed_version
;
511 struct ata_host
*host
;
512 int board_id
= (int) ent
->driver_data
;
513 const int *bar_sizes
;
516 if (!printed_version
++)
517 dev_printk(KERN_DEBUG
, &pdev
->dev
, "version " DRV_VERSION
"\n");
519 rc
= pcim_enable_device(pdev
);
523 if (board_id
== vt6420
) {
524 pci_read_config_byte(pdev
, SATA_PATA_SHARING
, &tmp8
);
525 if (tmp8
& SATA_2DEV
) {
526 dev_printk(KERN_ERR
, &pdev
->dev
,
527 "SATA master/slave not supported (0x%x)\n",
532 bar_sizes
= &svia_bar_sizes
[0];
534 bar_sizes
= &vt6421_bar_sizes
[0];
537 for (i
= 0; i
< ARRAY_SIZE(svia_bar_sizes
); i
++)
538 if ((pci_resource_start(pdev
, i
) == 0) ||
539 (pci_resource_len(pdev
, i
) < bar_sizes
[i
])) {
540 dev_printk(KERN_ERR
, &pdev
->dev
,
541 "invalid PCI BAR %u (sz 0x%llx, val 0x%llx)\n",
543 (unsigned long long)pci_resource_start(pdev
, i
),
544 (unsigned long long)pci_resource_len(pdev
, i
));
548 if (board_id
== vt6420
)
549 rc
= vt6420_prepare_host(pdev
, &host
);
551 rc
= vt6421_prepare_host(pdev
, &host
);
555 svia_configure(pdev
);
557 pci_set_master(pdev
);
558 return ata_host_activate(host
, pdev
->irq
, ata_interrupt
, IRQF_SHARED
,
562 static int __init
svia_init(void)
564 return pci_register_driver(&svia_pci_driver
);
567 static void __exit
svia_exit(void)
569 pci_unregister_driver(&svia_pci_driver
);
572 module_init(svia_init
);
573 module_exit(svia_exit
);