drivers/scsi/sata_via.c

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