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         .fill_sg                = ata_fill_sg,
 112         .eng_timeout            = ata_eng_timeout,
 113
 114         .irq_handler            = ata_interrupt,
 115
 116         .scr_read               = svia_scr_read,
 117         .scr_write              = svia_scr_write,
 118
 119         .port_start             = ata_port_start,
 120         .port_stop              = ata_port_stop,
 121 };
 122
 123 MODULE_AUTHOR("Jeff Garzik");
 124 MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
 125 MODULE_LICENSE("GPL");
 126 MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
 127
 128 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
 129 {
 130         if (sc_reg > SCR_CONTROL)
 131                 return 0xffffffffU;
 132         return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
 133 }
 134
 135 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 136 {
 137         if (sc_reg > SCR_CONTROL)
 138                 return;
 139         outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
 140 }
 141
 142 static const unsigned int svia_bar_sizes[] = {
 143         8, 4, 8, 4, 16, 256
 144 };
 145
 146 static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
 147 {
 148         return addr + (port * 128);
 149 }
 150
 151 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 152 {
 153         static int printed_version;
 154         unsigned int i;
 155         int rc;
 156         struct ata_probe_ent *probe_ent;
 157         u8 tmp8;
 158
 159         if (!printed_version++)
 160                 printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
 161
 162         rc = pci_enable_device(pdev);
 163         if (rc)
 164                 return rc;
 165
 166         rc = pci_request_regions(pdev, DRV_NAME);
 167         if (rc)
 168                 goto err_out;
 169
 170         pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
 171         if (tmp8 & SATA_2DEV) {
 172                 printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
 173                        pci_name(pdev), (int) tmp8);
 174                 rc = -EIO;
 175                 goto err_out_regions;
 176         }
 177
 178         for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
 179                 if ((pci_resource_start(pdev, i) == 0) ||
 180                     (pci_resource_len(pdev, i) < svia_bar_sizes[i])) {
 181                         printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
 182                                pci_name(pdev), i,
 183                                pci_resource_start(pdev, i),
 184                                pci_resource_len(pdev, i));
 185                         rc = -ENODEV;
 186                         goto err_out_regions;
 187                 }
 188
 189         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
 190         if (rc)
 191                 goto err_out_regions;
 192         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
 193         if (rc)
 194                 goto err_out_regions;
 195
 196         probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
 197         if (!probe_ent) {
 198                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
 199                        pci_name(pdev));
 200                 rc = -ENOMEM;
 201                 goto err_out_regions;
 202         }
 203         memset(probe_ent, 0, sizeof(*probe_ent));
 204         INIT_LIST_HEAD(&probe_ent->node);
 205         probe_ent->pdev = pdev;
 206         probe_ent->sht = &svia_sht;
 207         probe_ent->host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST |
 208                                 ATA_FLAG_NO_LEGACY;
 209         probe_ent->port_ops = &svia_sata_ops;
 210         probe_ent->n_ports = 2;
 211         probe_ent->irq = pdev->irq;
 212         probe_ent->irq_flags = SA_SHIRQ;
 213         probe_ent->pio_mask = 0x1f;
 214         probe_ent->udma_mask = 0x7f;
 215
 216         probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
 217         ata_std_ports(&probe_ent->port[0]);
 218         probe_ent->port[0].altstatus_addr =
 219         probe_ent->port[0].ctl_addr =
 220                 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
 221         probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
 222         probe_ent->port[0].scr_addr =
 223                 svia_scr_addr(pci_resource_start(pdev, 5), 0);
 224
 225         probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
 226         ata_std_ports(&probe_ent->port[1]);
 227         probe_ent->port[1].altstatus_addr =
 228         probe_ent->port[1].ctl_addr =
 229                 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
 230         probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
 231         probe_ent->port[1].scr_addr =
 232                 svia_scr_addr(pci_resource_start(pdev, 5), 1);
 233
 234         pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
 235         printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
 236                pci_name(pdev),
 237                (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
 238
 239         /* make sure SATA channels are enabled */
 240         pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
 241         if ((tmp8 & ENAB_ALL) != ENAB_ALL) {
 242                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
 243                        pci_name(pdev), (int) tmp8);
 244                 tmp8 |= ENAB_ALL;
 245                 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
 246         }
 247
 248         /* make sure interrupts for each channel sent to us */
 249         pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
 250         if ((tmp8 & INT_GATE_ALL) != INT_GATE_ALL) {
 251                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
 252                        pci_name(pdev), (int) tmp8);
 253                 tmp8 |= INT_GATE_ALL;
 254                 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
 255         }
 256
 257         /* make sure native mode is enabled */
 258         pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
 259         if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
 260                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
 261                        pci_name(pdev), (int) tmp8);
 262                 tmp8 |= NATIVE_MODE_ALL;
 263                 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
 264         }
 265
 266         pci_set_master(pdev);
 267
 268         /* FIXME: check ata_device_add return value */
 269         ata_device_add(probe_ent);
 270         kfree(probe_ent);
 271
 272         return 0;
 273
 274 err_out_regions:
 275         pci_release_regions(pdev);
 276 err_out:
 277         pci_disable_device(pdev);
 278         return rc;
 279 }
 280
 281 static int __init svia_init(void)
 282 {
 283         return pci_module_init(&svia_pci_driver);
 284 }
 285
 286 static void __exit svia_exit(void)
 287 {
 288         pci_unregister_driver(&svia_pci_driver);
 289 }
 290
 291 module_init(svia_init);
 292 module_exit(svia_exit);
 293