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 };
 106
 107 static struct ata_port_operations svia_sata_ops = {
 108         .port_disable           = ata_port_disable,
 109
 110         .tf_load                = ata_tf_load,
 111         .tf_read                = ata_tf_read,
 112         .check_status           = ata_check_status,
 113         .exec_command           = ata_exec_command,
 114         .dev_select             = ata_std_dev_select,
 115
 116         .phy_reset              = sata_phy_reset,
 117
 118         .bmdma_setup            = ata_bmdma_setup,
 119         .bmdma_start            = ata_bmdma_start,
 120         .bmdma_stop             = ata_bmdma_stop,
 121         .bmdma_status           = ata_bmdma_status,
 122
 123         .qc_prep                = ata_qc_prep,
 124         .qc_issue               = ata_qc_issue_prot,
 125
 126         .eng_timeout            = ata_eng_timeout,
 127
 128         .irq_handler            = ata_interrupt,
 129         .irq_clear              = ata_bmdma_irq_clear,
 130
 131         .scr_read               = svia_scr_read,
 132         .scr_write              = svia_scr_write,
 133
 134         .port_start             = ata_port_start,
 135         .port_stop              = ata_port_stop,
 136 };
 137
 138 static struct ata_port_info svia_port_info = {
 139         .sht            = &svia_sht,
 140         .host_flags     = ATA_FLAG_SATA | ATA_FLAG_SRST | ATA_FLAG_NO_LEGACY,
 141         .pio_mask       = 0x1f,
 142         .mwdma_mask     = 0x07,
 143         .udma_mask      = 0x7f,
 144         .port_ops       = &svia_sata_ops,
 145 };
 146
 147 MODULE_AUTHOR("Jeff Garzik");
 148 MODULE_DESCRIPTION("SCSI low-level driver for VIA SATA controllers");
 149 MODULE_LICENSE("GPL");
 150 MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
 151 MODULE_VERSION(DRV_VERSION);
 152
 153 static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
 154 {
 155         if (sc_reg > SCR_CONTROL)
 156                 return 0xffffffffU;
 157         return inl(ap->ioaddr.scr_addr + (4 * sc_reg));
 158 }
 159
 160 static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 161 {
 162         if (sc_reg > SCR_CONTROL)
 163                 return;
 164         outl(val, ap->ioaddr.scr_addr + (4 * sc_reg));
 165 }
 166
 167 static const unsigned int svia_bar_sizes[] = {
 168         8, 4, 8, 4, 16, 256
 169 };
 170
 171 static const unsigned int vt6421_bar_sizes[] = {
 172         16, 16, 16, 16, 32, 128
 173 };
 174
 175 static unsigned long svia_scr_addr(unsigned long addr, unsigned int port)
 176 {
 177         return addr + (port * 128);
 178 }
 179
 180 static unsigned long vt6421_scr_addr(unsigned long addr, unsigned int port)
 181 {
 182         return addr + (port * 64);
 183 }
 184
 185 static void vt6421_init_addrs(struct ata_probe_ent *probe_ent,
 186                               struct pci_dev *pdev,
 187                               unsigned int port)
 188 {
 189         unsigned long reg_addr = pci_resource_start(pdev, port);
 190         unsigned long bmdma_addr = pci_resource_start(pdev, 4) + (port * 8);
 191         unsigned long scr_addr;
 192
 193         probe_ent->port[port].cmd_addr = reg_addr;
 194         probe_ent->port[port].altstatus_addr =
 195         probe_ent->port[port].ctl_addr = (reg_addr + 8) | ATA_PCI_CTL_OFS;
 196         probe_ent->port[port].bmdma_addr = bmdma_addr;
 197
 198         scr_addr = vt6421_scr_addr(pci_resource_start(pdev, 5), port);
 199         probe_ent->port[port].scr_addr = scr_addr;
 200
 201         ata_std_ports(&probe_ent->port[port]);
 202 }
 203
 204 static struct ata_probe_ent *vt6420_init_probe_ent(struct pci_dev *pdev)
 205 {
 206         struct ata_probe_ent *probe_ent;
 207         struct ata_port_info *ppi = &svia_port_info;
 208
 209         probe_ent = ata_pci_init_native_mode(pdev, &ppi);
 210         if (!probe_ent)
 211                 return NULL;
 212
 213         probe_ent->port[0].scr_addr =
 214                 svia_scr_addr(pci_resource_start(pdev, 5), 0);
 215         probe_ent->port[1].scr_addr =
 216                 svia_scr_addr(pci_resource_start(pdev, 5), 1);
 217
 218         return probe_ent;
 219 }
 220
 221 static struct ata_probe_ent *vt6421_init_probe_ent(struct pci_dev *pdev)
 222 {
 223         struct ata_probe_ent *probe_ent;
 224         unsigned int i;
 225
 226         probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
 227         if (!probe_ent)
 228                 return NULL;
 229
 230         memset(probe_ent, 0, sizeof(*probe_ent));
 231         probe_ent->dev = pci_dev_to_dev(pdev);
 232         INIT_LIST_HEAD(&probe_ent->node);
 233
 234         probe_ent->sht          = &svia_sht;
 235         probe_ent->host_flags   = ATA_FLAG_SATA | ATA_FLAG_SATA_RESET |
 236                                   ATA_FLAG_NO_LEGACY;
 237         probe_ent->port_ops     = &svia_sata_ops;
 238         probe_ent->n_ports      = N_PORTS;
 239         probe_ent->irq          = pdev->irq;
 240         probe_ent->irq_flags    = SA_SHIRQ;
 241         probe_ent->pio_mask     = 0x1f;
 242         probe_ent->mwdma_mask   = 0x07;
 243         probe_ent->udma_mask    = 0x7f;
 244
 245         for (i = 0; i < N_PORTS; i++)
 246                 vt6421_init_addrs(probe_ent, pdev, i);
 247
 248         return probe_ent;
 249 }
 250
 251 static void svia_configure(struct pci_dev *pdev)
 252 {
 253         u8 tmp8;
 254
 255         pci_read_config_byte(pdev, PCI_INTERRUPT_LINE, &tmp8);
 256         printk(KERN_INFO DRV_NAME "(%s): routed to hard irq line %d\n",
 257                pci_name(pdev),
 258                (int) (tmp8 & 0xf0) == 0xf0 ? 0 : tmp8 & 0x0f);
 259
 260         /* make sure SATA channels are enabled */
 261         pci_read_config_byte(pdev, SATA_CHAN_ENAB, &tmp8);
 262         if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
 263                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channels (0x%x)\n",
 264                        pci_name(pdev), (int) tmp8);
 265                 tmp8 |= ALL_PORTS;
 266                 pci_write_config_byte(pdev, SATA_CHAN_ENAB, tmp8);
 267         }
 268
 269         /* make sure interrupts for each channel sent to us */
 270         pci_read_config_byte(pdev, SATA_INT_GATE, &tmp8);
 271         if ((tmp8 & ALL_PORTS) != ALL_PORTS) {
 272                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel interrupts (0x%x)\n",
 273                        pci_name(pdev), (int) tmp8);
 274                 tmp8 |= ALL_PORTS;
 275                 pci_write_config_byte(pdev, SATA_INT_GATE, tmp8);
 276         }
 277
 278         /* make sure native mode is enabled */
 279         pci_read_config_byte(pdev, SATA_NATIVE_MODE, &tmp8);
 280         if ((tmp8 & NATIVE_MODE_ALL) != NATIVE_MODE_ALL) {
 281                 printk(KERN_DEBUG DRV_NAME "(%s): enabling SATA channel native mode (0x%x)\n",
 282                        pci_name(pdev), (int) tmp8);
 283                 tmp8 |= NATIVE_MODE_ALL;
 284                 pci_write_config_byte(pdev, SATA_NATIVE_MODE, tmp8);
 285         }
 286 }
 287
 288 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 289 {
 290         static int printed_version;
 291         unsigned int i;
 292         int rc;
 293         struct ata_probe_ent *probe_ent;
 294         int board_id = (int) ent->driver_data;
 295         const int *bar_sizes;
 296         int pci_dev_busy = 0;
 297         u8 tmp8;
 298
 299         if (!printed_version++)
 300                 printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
 301
 302         rc = pci_enable_device(pdev);
 303         if (rc)
 304                 return rc;
 305
 306         rc = pci_request_regions(pdev, DRV_NAME);
 307         if (rc) {
 308                 pci_dev_busy = 1;
 309                 goto err_out;
 310         }
 311
 312         if (board_id == vt6420) {
 313                 pci_read_config_byte(pdev, SATA_PATA_SHARING, &tmp8);
 314                 if (tmp8 & SATA_2DEV) {
 315                         printk(KERN_ERR DRV_NAME "(%s): SATA master/slave not supported (0x%x)\n",
 316                         pci_name(pdev), (int) tmp8);
 317                         rc = -EIO;
 318                         goto err_out_regions;
 319                 }
 320
 321                 bar_sizes = &svia_bar_sizes[0];
 322         } else {
 323                 bar_sizes = &vt6421_bar_sizes[0];
 324         }
 325
 326         for (i = 0; i < ARRAY_SIZE(svia_bar_sizes); i++)
 327                 if ((pci_resource_start(pdev, i) == 0) ||
 328                     (pci_resource_len(pdev, i) < bar_sizes[i])) {
 329                         printk(KERN_ERR DRV_NAME "(%s): invalid PCI BAR %u (sz 0x%lx, val 0x%lx)\n",
 330                                pci_name(pdev), i,
 331                                pci_resource_start(pdev, i),
 332                                pci_resource_len(pdev, i));
 333                         rc = -ENODEV;
 334                         goto err_out_regions;
 335                 }
 336
 337         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
 338         if (rc)
 339                 goto err_out_regions;
 340         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
 341         if (rc)
 342                 goto err_out_regions;
 343
 344         if (board_id == vt6420)
 345                 probe_ent = vt6420_init_probe_ent(pdev);
 346         else
 347                 probe_ent = vt6421_init_probe_ent(pdev);
 348
 349         if (!probe_ent) {
 350                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
 351                        pci_name(pdev));
 352                 rc = -ENOMEM;
 353                 goto err_out_regions;
 354         }
 355
 356         svia_configure(pdev);
 357
 358         pci_set_master(pdev);
 359
 360         /* FIXME: check ata_device_add return value */
 361         ata_device_add(probe_ent);
 362         kfree(probe_ent);
 363
 364         return 0;
 365
 366 err_out_regions:
 367         pci_release_regions(pdev);
 368 err_out:
 369         if (!pci_dev_busy)
 370                 pci_disable_device(pdev);
 371         return rc;
 372 }
 373
 374 static int __init svia_init(void)
 375 {
 376         return pci_module_init(&svia_pci_driver);
 377 }
 378
 379 static void __exit svia_exit(void)
 380 {
 381         pci_unregister_driver(&svia_pci_driver);
 382 }
 383
 384 module_init(svia_init);
 385 module_exit(svia_exit);
 386