?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] PCI: pci_assign_unassigned_resources() on x86
[linux-2.6/verdex.git] / drivers / scsi / sata_via.c
blobf43183c19a12184ebd6902eadf154bc836a7e249
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 .host_stop = ata_host_stop,
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
Verdex Pro support