Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux...
[linux-2.6] / drivers / scsi / sata_via.c
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