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 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/pci.h>
  32 #include <linux/init.h>
  33 #include <linux/blkdev.h>
  34 #include <linux/delay.h>
  35 #include "scsi.h"
  36 #include <scsi/scsi_host.h>
  37 #include <linux/libata.h>
  38 #include <asm/io.h>
  39
  40 #define DRV_NAME        "sata_via"
  41 #define DRV_VERSION     "0.20"
  42
  43 enum {
  44         via_sata                = 0,
  45
  46         SATA_CHAN_ENAB          = 0x40, /* SATA channel enable */
  47         SATA_INT_GATE           = 0x41, /* SATA interrupt gating */
  48         SATA_NATIVE_MODE        = 0x42, /* Native mode enable */
  49         SATA_PATA_SHARING       = 0x49, /* PATA/SATA sharing func ctrl */
  50
  51         PORT0                   = (1 << 1),
  52         PORT1                   = (1 << 0),
  53
  54         ENAB_ALL                = PORT0 | PORT1,
  55
  56         INT_GATE_ALL            = PORT0 | PORT1,
  57
  58         NATIVE_MODE_ALL         = (1 << 7) | (1 << 6) | (1 << 5) | (1 << 4),
  59
  60         SATA_EXT_PHY            = (1 << 6), /* 0==use PATA, 1==ext phy */
  61         SATA_2DEV               = (1 << 5), /* SATA is master/slave */
  62 };
  63
  64 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
  65 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg);
  66 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
  67
  68 static struct pci_device_id svia_pci_tbl[] = {
  69         { 0x1106, 0x3149, PCI_ANY_ID, PCI_ANY_ID, 0, 0, via_sata },
  70
  71         { }     /* terminate list */
  72 };
  73
  74 static struct pci_driver svia_pci_driver = {
  75         .name                   = DRV_NAME,
  76         .id_table               = svia_pci_tbl,
  77         .probe                  = svia_init_one,
  78         .remove                 = ata_pci_remove_one,
  79 };
  80
  81 static Scsi_Host_Template svia_sht = {
  82         .module                 = THIS_MODULE,
  83         .name                   = DRV_NAME,
  84         .queuecommand           = ata_scsi_queuecmd,
  85         .eh_strategy_handler    = ata_scsi_error,
  86         .can_queue              = ATA_DEF_QUEUE,
  87         .this_id                = ATA_SHT_THIS_ID,
  88         .sg_tablesize           = LIBATA_MAX_PRD,
  89         .max_sectors            = ATA_MAX_SECTORS,
  90         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
  91         .emulated               = ATA_SHT_EMULATED,
  92         .use_clustering         = ATA_SHT_USE_CLUSTERING,
  93         .proc_name              = DRV_NAME,
  94         .dma_boundary           = ATA_DMA_BOUNDARY,
  95         .slave_configure        = ata_scsi_slave_config,
  96         .bios_param             = ata_std_bios_param,
  97 };
  98
  99 static struct ata_port_operations svia_sata_ops = {
 100         .port_disable           = ata_port_disable,
 101
 102         .tf_load                = ata_tf_load_pio,
 103         .tf_read                = ata_tf_read_pio,
 104         .check_status           = ata_check_status_pio,
 105         .exec_command           = ata_exec_command_pio,
 106
 107         .phy_reset              = sata_phy_reset,
 108
 109         .bmdma_setup            = ata_bmdma_setup_pio,
 110         .bmdma_start            = ata_bmdma_start_pio,
 111         .qc_prep                = ata_qc_prep,
 112         .qc_issue               = ata_qc_issue_prot,
 113
 114         .eng_timeout            = ata_eng_timeout,
 115
 116         .irq_handler            = ata_interrupt,
 117         .irq_clear              = ata_bmdma_irq_clear,
 118
 119         .scr_read               = svia_scr_read,
 120         .scr_write              = svia_scr_write,
 121
 122         .port_start             = ata_port_start,
 123         .port_stop              = ata_port_stop,
 124 };
 125
 126 MODULE_AUTHOR("Jeff Garzik");
 127 MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
 128 MODULE_LICENSE("GPL");
 129 MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
 130
 131 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
 132 {
 133         if (sc_reg > SCR_CONTROL)
 134                 return 0xffffffffU;
 135         return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
 136 }
 137
 138 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 139 {
 140         if (sc_reg > SCR_CONTROL)
 141                 return;
 142         outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
 143 }
 144
 145 static const unsigned int svia_bar_sizes[] = {
 146         8, 4, 8, 4, 16, 256
 147 };
 148
 149 static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
 150 {
 151         return addr + (port * 128);
 152 }
 153
 154 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 155 {
 156         static int printed_version;
 157         unsigned int i;
 158         int rc;
 159         struct ata_probe_ent *probe_ent;
 160         u8 tmp8;
 161
 162         if (!printed_version++)
 163                 printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
 164
 165         rc = pci_enable_device(pdev);
 166         if (rc)
 167                 return rc;
 168
 169         rc = pci_request_regions(pdev, DRV_NAME);
 170         if (rc)
 171                 goto err_out;
 172
 173         pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
 174         if (tmp8 & SATA_2DEV) {
 175                 printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
 176                        pci_name(pdev), (int) tmp8);
 177                 rc = -EIO;
 178                 goto err_out_regions;
 179         }
 180
 181         for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
 182                 if ((pci_resource_start(pdev, i) == 0) ||
 183                     (pci_resource_len(pdev, i) < svia_bar_sizes[i])) {
 184                         printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
 185                                pci_name(pdev), i,
 186                                pci_resource_start(pdev, i),
 187                                pci_resource_len(pdev, i));
 188                         rc = -ENODEV;
 189                         goto err_out_regions;
 190                 }
 191
 192         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
 193         if (rc)
 194                 goto err_out_regions;
 195         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
 196         if (rc)
 197                 goto err_out_regions;
 198
 199         probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
 200         if (!probe_ent) {
 201                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
 202                        pci_name(pdev));
 203                 rc = -ENOMEM;
 204                 goto err_out_regions;
 205         }
 206         memset(probe_ent, 0, sizeof(*probe_ent));
 207         INIT_LIST_HEAD(&probe_ent->node);
 208         probe_ent->pdev = pdev;
 209         probe_ent->sht = &svia_sht;
 210         probe_ent->host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST |
 211                                 ATA_FLAG_NO_LEGACY;
 212         probe_ent->port_ops = &svia_sata_ops;
 213         probe_ent->n_ports = 2;
 214         probe_ent->irq = pdev->irq;
 215         probe_ent->irq_flags = SA_SHIRQ;
 216         probe_ent->pio_mask = 0x1f;
 217         probe_ent->udma_mask = 0x7f;
 218
 219         probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
 220         ata_std_ports(&probe_ent->port[0]);
 221         probe_ent->port[0].altstatus_addr =
 222         probe_ent->port[0].ctl_addr =
 223                 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
 224         probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
 225         probe_ent->port[0].scr_addr =
 226                 svia_scr_addr(pci_resource_start(pdev, 5), 0);
 227
 228         probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
 229         ata_std_ports(&probe_ent->port[1]);
 230         probe_ent->port[1].altstatus_addr =
 231         probe_ent->port[1].ctl_addr =
 232                 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
 233         probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
 234         probe_ent->port[1].scr_addr =
 235                 svia_scr_addr(pci_resource_start(pdev, 5), 1);
 236
 237         pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
 238         printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
 239                pci_name(pdev),
 240                (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
 241
 242         /* make sure SATA channels are enabled */
 243         pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
 244         if ((tmp8 & ENAB_ALL) != ENAB_ALL) {
 245                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
 246                        pci_name(pdev), (int) tmp8);
 247                 tmp8 |= ENAB_ALL;
 248                 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
 249         }
 250
 251         /* make sure interrupts for each channel sent to us */
 252         pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
 253         if ((tmp8 & INT_GATE_ALL) != INT_GATE_ALL) {
 254                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
 255                        pci_name(pdev), (int) tmp8);
 256                 tmp8 |= INT_GATE_ALL;
 257                 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
 258         }
 259
 260         /* make sure native mode is enabled */
 261         pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
 262         if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
 263                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
 264                        pci_name(pdev), (int) tmp8);
 265                 tmp8 |= NATIVE_MODE_ALL;
 266                 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
 267         }
 268
 269         pci_set_master(pdev);
 270
 271         /* FIXME: check ata_device_add return value */
 272         ata_device_add(probe_ent);
 273         kfree(probe_ent);
 274
 275         return 0;
 276
 277 err_out_regions:
 278         pci_release_regions(pdev);
 279 err_out:
 280         pci_disable_device(pdev);
 281         return rc;
 282 }
 283
 284 static int __init svia_init(void)
 285 {
 286         return pci_module_init(&svia_pci_driver);
 287 }
 288
 289 static void __exit svia_exit(void)
 290 {
 291         pci_unregister_driver(&svia_pci_driver);
 292 }
 293
 294 module_init(svia_init);
 295 module_exit(svia_exit);
 296