Auto-update from upstream
[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         .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