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