?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / scsi / sata_via.c
blob3a7830667277f35f71a83db5705b8cb2d376bafc
1 /*
2 sata_via.c - VIA Serial ATA controllers
3
4 Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 Please ALWAYS copy linux-ide@vger.kernel.org
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,
137 };
138
139 static struct ata_port_info svia_port_info = {
140 .sht = &svia_sht,
141 .host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST | ATA_FLAG_NO_LEGACY,
142 .pio_mask = 0x1f,
143 .mwdma_mask = 0x07,
144 .udma_mask = 0x7f,
145 .port_ops = &svia_sata_ops,
146 };
147
148 MODULE_AUTHOR("Jeff Garzik");
149 MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
150 MODULE_LICENSE("GPL");
151 MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
152 MODULE_VERSION(DRV_VERSION);
153
154 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
155 {
156 if (sc_reg > SCR_CONTROL)
157 return 0xffffffffU;
158 return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
159 }
160
161 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
162 {
163 if (sc_reg > SCR_CONTROL)
164 return;
165 outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
166 }
167
168 static const unsigned int svia_bar_sizes[] = {
169 8, 4, 8, 4, 16, 256
170 };
171
172 static const unsigned int vt6421_bar_sizes[] = {
173 16, 16, 16, 16, 32, 128
174 };
175
176 static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
177 {
178 return addr + (port * 128);
179 }
180
181 static unsigned long vt6421_scr_addr(unsigned long addr, unsigned int port)
182 {
183 return addr + (port * 64);
184 }
185
186 static void vt6421_init_addrs(struct ata_probe_ent *probe_ent,
187 struct pci_dev *pdev,
188 unsigned int port)
189 {
190 unsigned long reg_addr = pci_resource_start(pdev, port);
191 unsigned long bmdma_addr = pci_resource_start(pdev, 4) + (port * 8);
192 unsigned long scr_addr;
193
194 probe_ent->port[port].cmd_addr = reg_addr;
195 probe_ent->port[port].altstatus_addr =
196 probe_ent->port[port].ctl_addr = (reg_addr + 8) | ATA_PCI_CTL_OFS;
197 probe_ent->port[port].bmdma_addr = bmdma_addr;
198
199 scr_addr = vt6421_scr_addr(pci_resource_start(pdev, 5), port);
200 probe_ent->port[port].scr_addr = scr_addr;
201
202 ata_std_ports(&probe_ent->port[port]);
203 }
204
205 static struct ata_probe_ent *vt6420_init_probe_ent(struct pci_dev *pdev)
206 {
207 struct ata_probe_ent *probe_ent;
208 struct ata_port_info *ppi = &svia_port_info;
209
210 probe_ent = ata_pci_init_native_mode(pdev, &ppi);
211 if (!probe_ent)
212 return NULL;
213
214 probe_ent->port[0].scr_addr =
215 svia_scr_addr(pci_resource_start(pdev, 5), 0);
216 probe_ent->port[1].scr_addr =
217 svia_scr_addr(pci_resource_start(pdev, 5), 1);
218
219 return probe_ent;
220 }
221
222 static struct ata_probe_ent *vt6421_init_probe_ent(struct pci_dev *pdev)
223 {
224 struct ata_probe_ent *probe_ent;
225 unsigned int i;
226
227 probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
228 if (!probe_ent)
229 return NULL;
230
231 memset(probe_ent, 0, sizeof(*probe_ent));
232 probe_ent->dev = pci_dev_to_dev(pdev);
233 INIT_LIST_HEAD(&probe_ent->node);
234
235 probe_ent->sht = &svia_sht;
236 probe_ent->host_flags = ATA_FLAG_SATA | ATA_FLAG_SATA_RESET |
237 ATA_FLAG_NO_LEGACY;
238 probe_ent->port_ops = &svia_sata_ops;
239 probe_ent->n_ports = N_PORTS;
240 probe_ent->irq = pdev->irq;
241 probe_ent->irq_flags = SA_SHIRQ;
242 probe_ent->pio_mask = 0x1f;
243 probe_ent->mwdma_mask = 0x07;
244 probe_ent->udma_mask = 0x7f;
245
246 for (i = 0; i < N_PORTS; i++)
247 vt6421_init_addrs(probe_ent, pdev, i);
248
249 return probe_ent;
250 }
251
252 static void svia_configure(struct pci_dev *pdev)
253 {
254 u8 tmp8;
255
256 pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
257 printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
258 pci_name(pdev),
259 (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
260
261 /* make sure SATA channels are enabled */
262 pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
263 if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
264 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
265 pci_name(pdev), (int) tmp8);
266 tmp8 |= ALL_PORTS;
267 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
268 }
269
270 /* make sure interrupts for each channel sent to us */
271 pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
272 if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
273 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
274 pci_name(pdev), (int) tmp8);
275 tmp8 |= ALL_PORTS;
276 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
277 }
278
279 /* make sure native mode is enabled */
280 pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
281 if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
282 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
283 pci_name(pdev), (int) tmp8);
284 tmp8 |= NATIVE_MODE_ALL;
285 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
286 }
287 }
288
289 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
290 {
291 static int printed_version;
292 unsigned int i;
293 int rc;
294 struct ata_probe_ent *probe_ent;
295 int board_id = (int) ent->driver_data;
296 const int *bar_sizes;
297 int pci_dev_busy = 0;
298 u8 tmp8;
299
300 if (!printed_version++)
301 printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
302
303 rc = pci_enable_device(pdev);
304 if (rc)
305 return rc;
306
307 rc = pci_request_regions(pdev, DRV_NAME);
308 if (rc) {
309 pci_dev_busy = 1;
310 goto err_out;
311 }
312
313 if (board_id == vt6420) {
314 pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
315 if (tmp8 & SATA_2DEV) {
316 printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
317 pci_name(pdev), (int) tmp8);
318 rc = -EIO;
319 goto err_out_regions;
320 }
321
322 bar_sizes = &svia_bar_sizes[0];
323 } else {
324 bar_sizes = &vt6421_bar_sizes[0];
325 }
326
327 for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
328 if ((pci_resource_start(pdev, i) == 0) ||
329 (pci_resource_len(pdev, i) < bar_sizes[i])) {
330 printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
331 pci_name(pdev), i,
332 pci_resource_start(pdev, i),
333 pci_resource_len(pdev, i));
334 rc = -ENODEV;
335 goto err_out_regions;
336 }
337
338 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
339 if (rc)
340 goto err_out_regions;
341 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
342 if (rc)
343 goto err_out_regions;
344
345 if (board_id == vt6420)
346 probe_ent = vt6420_init_probe_ent(pdev);
347 else
348 probe_ent = vt6421_init_probe_ent(pdev);
349
350 if (!probe_ent) {
351 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
352 pci_name(pdev));
353 rc = -ENOMEM;
354 goto err_out_regions;
355 }
356
357 svia_configure(pdev);
358
359 pci_set_master(pdev);
360
361 /* FIXME: check ata_device_add return value */
362 ata_device_add(probe_ent);
363 kfree(probe_ent);
364
365 return 0;
366
367 err_out_regions:
368 pci_release_regions(pdev);
369 err_out:
370 if (!pci_dev_busy)
371 pci_disable_device(pdev);
372 return rc;
373 }
374
375 static int __init svia_init(void)
376 {
377 return pci_module_init(&svia_pci_driver);
378 }
379
380 static void __exit svia_exit(void)
381 {
382 pci_unregister_driver(&svia_pci_driver);
383 }
384
385 module_init(svia_init);
386 module_exit(svia_exit);
387
Verdex Pro support