drivers/ata/sata_mv.c

   1 /*
   2  * sata_mv.c - Marvell SATA support
   3  *
   4  * Copyright 2005: EMC Corporation, all rights reserved.
   5  * Copyright 2005 Red Hat, Inc.  All rights reserved.
   6  *
   7  * Please ALWAYS copy linux-ide@vger.kernel.org on emails.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; version 2 of the License.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 /*
  25   sata_mv TODO list:
  26
  27   1) Needs a full errata audit for all chipsets.  I implemented most
  28   of the errata workarounds found in the Marvell vendor driver, but
  29   I distinctly remember a couple workarounds (one related to PCI-X)
  30   are still needed.
  31
  32   4) Add NCQ support (easy to intermediate, once new-EH support appears)
  33
  34   5) Investigate problems with PCI Message Signalled Interrupts (MSI).
  35
  36   6) Add port multiplier support (intermediate)
  37
  38   8) Develop a low-power-consumption strategy, and implement it.
  39
  40   9) [Experiment, low priority] See if ATAPI can be supported using
  41   "unknown FIS" or "vendor-specific FIS" support, or something creative
  42   like that.
  43
  44   10) [Experiment, low priority] Investigate interrupt coalescing.
  45   Quite often, especially with PCI Message Signalled Interrupts (MSI),
  46   the overhead reduced by interrupt mitigation is quite often not
  47   worth the latency cost.
  48
  49   11) [Experiment, Marvell value added] Is it possible to use target
  50   mode to cross-connect two Linux boxes with Marvell cards?  If so,
  51   creating LibATA target mode support would be very interesting.
  52
  53   Target mode, for those without docs, is the ability to directly
  54   connect two SATA controllers.
  55
  56   13) Verify that 7042 is fully supported.  I only have a 6042.
  57
  58 */
  59
  60
  61 #include <linux/kernel.h>
  62 #include <linux/module.h>
  63 #include <linux/pci.h>
  64 #include <linux/init.h>
  65 #include <linux/blkdev.h>
  66 #include <linux/delay.h>
  67 #include <linux/interrupt.h>
  68 #include <linux/dma-mapping.h>
  69 #include <linux/device.h>
  70 #include <scsi/scsi_host.h>
  71 #include <scsi/scsi_cmnd.h>
  72 #include <scsi/scsi_device.h>
  73 #include <linux/libata.h>
  74
  75 #define DRV_NAME        "sata_mv"
  76 #define DRV_VERSION     "1.01"
  77
  78 enum {
  79         /* BAR's are enumerated in terms of pci_resource_start() terms */
  80         MV_PRIMARY_BAR          = 0,    /* offset 0x10: memory space */
  81         MV_IO_BAR               = 2,    /* offset 0x18: IO space */
  82         MV_MISC_BAR             = 3,    /* offset 0x1c: FLASH, NVRAM, SRAM */
  83
  84         MV_MAJOR_REG_AREA_SZ    = 0x10000,      /* 64KB */
  85         MV_MINOR_REG_AREA_SZ    = 0x2000,       /* 8KB */
  86
  87         MV_PCI_REG_BASE         = 0,
  88         MV_IRQ_COAL_REG_BASE    = 0x18000,      /* 6xxx part only */
  89         MV_IRQ_COAL_CAUSE               = (MV_IRQ_COAL_REG_BASE + 0x08),
  90         MV_IRQ_COAL_CAUSE_LO            = (MV_IRQ_COAL_REG_BASE + 0x88),
  91         MV_IRQ_COAL_CAUSE_HI            = (MV_IRQ_COAL_REG_BASE + 0x8c),
  92         MV_IRQ_COAL_THRESHOLD           = (MV_IRQ_COAL_REG_BASE + 0xcc),
  93         MV_IRQ_COAL_TIME_THRESHOLD      = (MV_IRQ_COAL_REG_BASE + 0xd0),
  94
  95         MV_SATAHC0_REG_BASE     = 0x20000,
  96         MV_FLASH_CTL            = 0x1046c,
  97         MV_GPIO_PORT_CTL        = 0x104f0,
  98         MV_RESET_CFG            = 0x180d8,
  99
 100         MV_PCI_REG_SZ           = MV_MAJOR_REG_AREA_SZ,
 101         MV_SATAHC_REG_SZ        = MV_MAJOR_REG_AREA_SZ,
 102         MV_SATAHC_ARBTR_REG_SZ  = MV_MINOR_REG_AREA_SZ,         /* arbiter */
 103         MV_PORT_REG_SZ          = MV_MINOR_REG_AREA_SZ,
 104
 105         MV_MAX_Q_DEPTH          = 32,
 106         MV_MAX_Q_DEPTH_MASK     = MV_MAX_Q_DEPTH - 1,
 107
 108         /* CRQB needs alignment on a 1KB boundary. Size == 1KB
 109          * CRPB needs alignment on a 256B boundary. Size == 256B
 110          * SG count of 176 leads to MV_PORT_PRIV_DMA_SZ == 4KB
 111          * ePRD (SG) entries need alignment on a 16B boundary. Size == 16B
 112          */
 113         MV_CRQB_Q_SZ            = (32 * MV_MAX_Q_DEPTH),
 114         MV_CRPB_Q_SZ            = (8 * MV_MAX_Q_DEPTH),
 115         MV_MAX_SG_CT            = 176,
 116         MV_SG_TBL_SZ            = (16 * MV_MAX_SG_CT),
 117         MV_PORT_PRIV_DMA_SZ     = (MV_CRQB_Q_SZ + MV_CRPB_Q_SZ + MV_SG_TBL_SZ),
 118
 119         MV_PORTS_PER_HC         = 4,
 120         /* == (port / MV_PORTS_PER_HC) to determine HC from 0-7 port */
 121         MV_PORT_HC_SHIFT        = 2,
 122         /* == (port % MV_PORTS_PER_HC) to determine hard port from 0-7 port */
 123         MV_PORT_MASK            = 3,
 124
 125         /* Host Flags */
 126         MV_FLAG_DUAL_HC         = (1 << 30),  /* two SATA Host Controllers */
 127         MV_FLAG_IRQ_COALESCE    = (1 << 29),  /* IRQ coalescing capability */
 128         MV_COMMON_FLAGS         = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 129                                   ATA_FLAG_MMIO | ATA_FLAG_NO_ATAPI |
 130                                   ATA_FLAG_PIO_POLLING,
 131         MV_6XXX_FLAGS           = MV_FLAG_IRQ_COALESCE,
 132
 133         CRQB_FLAG_READ          = (1 << 0),
 134         CRQB_TAG_SHIFT          = 1,
 135         CRQB_IOID_SHIFT         = 6,    /* CRQB Gen-II/IIE IO Id shift */
 136         CRQB_HOSTQ_SHIFT        = 17,   /* CRQB Gen-II/IIE HostQueTag shift */
 137         CRQB_CMD_ADDR_SHIFT     = 8,
 138         CRQB_CMD_CS             = (0x2 << 11),
 139         CRQB_CMD_LAST           = (1 << 15),
 140
 141         CRPB_FLAG_STATUS_SHIFT  = 8,
 142         CRPB_IOID_SHIFT_6       = 5,    /* CRPB Gen-II IO Id shift */
 143         CRPB_IOID_SHIFT_7       = 7,    /* CRPB Gen-IIE IO Id shift */
 144
 145         EPRD_FLAG_END_OF_TBL    = (1 << 31),
 146
 147         /* PCI interface registers */
 148
 149         PCI_COMMAND_OFS         = 0xc00,
 150
 151         PCI_MAIN_CMD_STS_OFS    = 0xd30,
 152         STOP_PCI_MASTER         = (1 << 2),
 153         PCI_MASTER_EMPTY        = (1 << 3),
 154         GLOB_SFT_RST            = (1 << 4),
 155
 156         MV_PCI_MODE             = 0xd00,
 157         MV_PCI_EXP_ROM_BAR_CTL  = 0xd2c,
 158         MV_PCI_DISC_TIMER       = 0xd04,
 159         MV_PCI_MSI_TRIGGER      = 0xc38,
 160         MV_PCI_SERR_MASK        = 0xc28,
 161         MV_PCI_XBAR_TMOUT       = 0x1d04,
 162         MV_PCI_ERR_LOW_ADDRESS  = 0x1d40,
 163         MV_PCI_ERR_HIGH_ADDRESS = 0x1d44,
 164         MV_PCI_ERR_ATTRIBUTE    = 0x1d48,
 165         MV_PCI_ERR_COMMAND      = 0x1d50,
 166
 167         PCI_IRQ_CAUSE_OFS               = 0x1d58,
 168         PCI_IRQ_MASK_OFS                = 0x1d5c,
 169         PCI_UNMASK_ALL_IRQS     = 0x7fffff,     /* bits 22-0 */
 170
 171         HC_MAIN_IRQ_CAUSE_OFS   = 0x1d60,
 172         HC_MAIN_IRQ_MASK_OFS    = 0x1d64,
 173         PORT0_ERR               = (1 << 0),     /* shift by port # */
 174         PORT0_DONE              = (1 << 1),     /* shift by port # */
 175         HC0_IRQ_PEND            = 0x1ff,        /* bits 0-8 = HC0's ports */
 176         HC_SHIFT                = 9,            /* bits 9-17 = HC1's ports */
 177         PCI_ERR                 = (1 << 18),
 178         TRAN_LO_DONE            = (1 << 19),    /* 6xxx: IRQ coalescing */
 179         TRAN_HI_DONE            = (1 << 20),    /* 6xxx: IRQ coalescing */
 180         PORTS_0_3_COAL_DONE     = (1 << 8),
 181         PORTS_4_7_COAL_DONE     = (1 << 17),
 182         PORTS_0_7_COAL_DONE     = (1 << 21),    /* 6xxx: IRQ coalescing */
 183         GPIO_INT                = (1 << 22),
 184         SELF_INT                = (1 << 23),
 185         TWSI_INT                = (1 << 24),
 186         HC_MAIN_RSVD            = (0x7f << 25), /* bits 31-25 */
 187         HC_MAIN_RSVD_5          = (0x1fff << 19), /* bits 31-19 */
 188         HC_MAIN_MASKED_IRQS     = (TRAN_LO_DONE | TRAN_HI_DONE |
 189                                    PORTS_0_7_COAL_DONE | GPIO_INT | TWSI_INT |
 190                                    HC_MAIN_RSVD),
 191         HC_MAIN_MASKED_IRQS_5   = (PORTS_0_3_COAL_DONE | PORTS_4_7_COAL_DONE |
 192                                    HC_MAIN_RSVD_5),
 193
 194         /* SATAHC registers */
 195         HC_CFG_OFS              = 0,
 196
 197         HC_IRQ_CAUSE_OFS        = 0x14,
 198         CRPB_DMA_DONE           = (1 << 0),     /* shift by port # */
 199         HC_IRQ_COAL             = (1 << 4),     /* IRQ coalescing */
 200         DEV_IRQ                 = (1 << 8),     /* shift by port # */
 201
 202         /* Shadow block registers */
 203         SHD_BLK_OFS             = 0x100,
 204         SHD_CTL_AST_OFS         = 0x20,         /* ofs from SHD_BLK_OFS */
 205
 206         /* SATA registers */
 207         SATA_STATUS_OFS         = 0x300,  /* ctrl, err regs follow status */
 208         SATA_ACTIVE_OFS         = 0x350,
 209         PHY_MODE3               = 0x310,
 210         PHY_MODE4               = 0x314,
 211         PHY_MODE2               = 0x330,
 212         MV5_PHY_MODE            = 0x74,
 213         MV5_LT_MODE             = 0x30,
 214         MV5_PHY_CTL             = 0x0C,
 215         SATA_INTERFACE_CTL      = 0x050,
 216
 217         MV_M2_PREAMP_MASK       = 0x7e0,
 218
 219         /* Port registers */
 220         EDMA_CFG_OFS            = 0,
 221         EDMA_CFG_Q_DEPTH        = 0,                    /* queueing disabled */
 222         EDMA_CFG_NCQ            = (1 << 5),
 223         EDMA_CFG_NCQ_GO_ON_ERR  = (1 << 14),            /* continue on error */
 224         EDMA_CFG_RD_BRST_EXT    = (1 << 11),            /* read burst 512B */
 225         EDMA_CFG_WR_BUFF_LEN    = (1 << 13),            /* write buffer 512B */
 226
 227         EDMA_ERR_IRQ_CAUSE_OFS  = 0x8,
 228         EDMA_ERR_IRQ_MASK_OFS   = 0xc,
 229         EDMA_ERR_D_PAR          = (1 << 0),     /* UDMA data parity err */
 230         EDMA_ERR_PRD_PAR        = (1 << 1),     /* UDMA PRD parity err */
 231         EDMA_ERR_DEV            = (1 << 2),     /* device error */
 232         EDMA_ERR_DEV_DCON       = (1 << 3),     /* device disconnect */
 233         EDMA_ERR_DEV_CON        = (1 << 4),     /* device connected */
 234         EDMA_ERR_SERR           = (1 << 5),     /* SError bits [WBDST] raised */
 235         EDMA_ERR_SELF_DIS       = (1 << 7),     /* Gen II/IIE self-disable */
 236         EDMA_ERR_SELF_DIS_5     = (1 << 8),     /* Gen I self-disable */
 237         EDMA_ERR_BIST_ASYNC     = (1 << 8),     /* BIST FIS or Async Notify */
 238         EDMA_ERR_TRANS_IRQ_7    = (1 << 8),     /* Gen IIE transprt layer irq */
 239         EDMA_ERR_CRQB_PAR       = (1 << 9),     /* CRQB parity error */
 240         EDMA_ERR_CRPB_PAR       = (1 << 10),    /* CRPB parity error */
 241         EDMA_ERR_INTRL_PAR      = (1 << 11),    /* internal parity error */
 242         EDMA_ERR_IORDY          = (1 << 12),    /* IORdy timeout */
 243         EDMA_ERR_LNK_CTRL_RX    = (0xf << 13),  /* link ctrl rx error */
 244         EDMA_ERR_LNK_CTRL_RX_2  = (1 << 15),
 245         EDMA_ERR_LNK_DATA_RX    = (0xf << 17),  /* link data rx error */
 246         EDMA_ERR_LNK_CTRL_TX    = (0x1f << 21), /* link ctrl tx error */
 247         EDMA_ERR_LNK_DATA_TX    = (0x1f << 26), /* link data tx error */
 248         EDMA_ERR_TRANS_PROTO    = (1 << 31),    /* transport protocol error */
 249         EDMA_ERR_OVERRUN_5      = (1 << 5),
 250         EDMA_ERR_UNDERRUN_5     = (1 << 6),
 251         EDMA_EH_FREEZE          = EDMA_ERR_D_PAR |
 252                                   EDMA_ERR_PRD_PAR |
 253                                   EDMA_ERR_DEV_DCON |
 254                                   EDMA_ERR_DEV_CON |
 255                                   EDMA_ERR_SERR |
 256                                   EDMA_ERR_SELF_DIS |
 257                                   EDMA_ERR_CRQB_PAR |
 258                                   EDMA_ERR_CRPB_PAR |
 259                                   EDMA_ERR_INTRL_PAR |
 260                                   EDMA_ERR_IORDY |
 261                                   EDMA_ERR_LNK_CTRL_RX_2 |
 262                                   EDMA_ERR_LNK_DATA_RX |
 263                                   EDMA_ERR_LNK_DATA_TX |
 264                                   EDMA_ERR_TRANS_PROTO,
 265         EDMA_EH_FREEZE_5        = EDMA_ERR_D_PAR |
 266                                   EDMA_ERR_PRD_PAR |
 267                                   EDMA_ERR_DEV_DCON |
 268                                   EDMA_ERR_DEV_CON |
 269                                   EDMA_ERR_OVERRUN_5 |
 270                                   EDMA_ERR_UNDERRUN_5 |
 271                                   EDMA_ERR_SELF_DIS_5 |
 272                                   EDMA_ERR_CRQB_PAR |
 273                                   EDMA_ERR_CRPB_PAR |
 274                                   EDMA_ERR_INTRL_PAR |
 275                                   EDMA_ERR_IORDY,
 276
 277         EDMA_REQ_Q_BASE_HI_OFS  = 0x10,
 278         EDMA_REQ_Q_IN_PTR_OFS   = 0x14,         /* also contains BASE_LO */
 279
 280         EDMA_REQ_Q_OUT_PTR_OFS  = 0x18,
 281         EDMA_REQ_Q_PTR_SHIFT    = 5,
 282
 283         EDMA_RSP_Q_BASE_HI_OFS  = 0x1c,
 284         EDMA_RSP_Q_IN_PTR_OFS   = 0x20,
 285         EDMA_RSP_Q_OUT_PTR_OFS  = 0x24,         /* also contains BASE_LO */
 286         EDMA_RSP_Q_PTR_SHIFT    = 3,
 287
 288         EDMA_CMD_OFS            = 0x28,         /* EDMA command register */
 289         EDMA_EN                 = (1 << 0),     /* enable EDMA */
 290         EDMA_DS                 = (1 << 1),     /* disable EDMA; self-negated */
 291         ATA_RST                 = (1 << 2),     /* reset trans/link/phy */
 292
 293         EDMA_IORDY_TMOUT        = 0x34,
 294         EDMA_ARB_CFG            = 0x38,
 295
 296         /* Host private flags (hp_flags) */
 297         MV_HP_FLAG_MSI          = (1 << 0),
 298         MV_HP_ERRATA_50XXB0     = (1 << 1),
 299         MV_HP_ERRATA_50XXB2     = (1 << 2),
 300         MV_HP_ERRATA_60X1B2     = (1 << 3),
 301         MV_HP_ERRATA_60X1C0     = (1 << 4),
 302         MV_HP_ERRATA_XX42A0     = (1 << 5),
 303         MV_HP_GEN_I             = (1 << 6),     /* Generation I: 50xx */
 304         MV_HP_GEN_II            = (1 << 7),     /* Generation II: 60xx */
 305         MV_HP_GEN_IIE           = (1 << 8),     /* Generation IIE: 6042/7042 */
 306
 307         /* Port private flags (pp_flags) */
 308         MV_PP_FLAG_EDMA_EN      = (1 << 0),     /* is EDMA engine enabled? */
 309         MV_PP_FLAG_HAD_A_RESET  = (1 << 2),     /* 1st hard reset complete? */
 310 };
 311
 312 #define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
 313 #define IS_GEN_II(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_II)
 314 #define IS_GEN_IIE(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_IIE)
 315
 316 enum {
 317         /* DMA boundary 0xffff is required by the s/g splitting
 318          * we need on /length/ in mv_fill-sg().
 319          */
 320         MV_DMA_BOUNDARY         = 0xffffU,
 321
 322         /* mask of register bits containing lower 32 bits
 323          * of EDMA request queue DMA address
 324          */
 325         EDMA_REQ_Q_BASE_LO_MASK = 0xfffffc00U,
 326
 327         /* ditto, for response queue */
 328         EDMA_RSP_Q_BASE_LO_MASK = 0xffffff00U,
 329 };
 330
 331 enum chip_type {
 332         chip_504x,
 333         chip_508x,
 334         chip_5080,
 335         chip_604x,
 336         chip_608x,
 337         chip_6042,
 338         chip_7042,
 339 };
 340
 341 /* Command ReQuest Block: 32B */
 342 struct mv_crqb {
 343         __le32                  sg_addr;
 344         __le32                  sg_addr_hi;
 345         __le16                  ctrl_flags;
 346         __le16                  ata_cmd[11];
 347 };
 348
 349 struct mv_crqb_iie {
 350         __le32                  addr;
 351         __le32                  addr_hi;
 352         __le32                  flags;
 353         __le32                  len;
 354         __le32                  ata_cmd[4];
 355 };
 356
 357 /* Command ResPonse Block: 8B */
 358 struct mv_crpb {
 359         __le16                  id;
 360         __le16                  flags;
 361         __le32                  tmstmp;
 362 };
 363
 364 /* EDMA Physical Region Descriptor (ePRD); A.K.A. SG */
 365 struct mv_sg {
 366         __le32                  addr;
 367         __le32                  flags_size;
 368         __le32                  addr_hi;
 369         __le32                  reserved;
 370 };
 371
 372 struct mv_port_priv {
 373         struct mv_crqb          *crqb;
 374         dma_addr_t              crqb_dma;
 375         struct mv_crpb          *crpb;
 376         dma_addr_t              crpb_dma;
 377         struct mv_sg            *sg_tbl;
 378         dma_addr_t              sg_tbl_dma;
 379
 380         unsigned int            req_idx;
 381         unsigned int            resp_idx;
 382
 383         u32                     pp_flags;
 384 };
 385
 386 struct mv_port_signal {
 387         u32                     amps;
 388         u32                     pre;
 389 };
 390
 391 struct mv_host_priv;
 392 struct mv_hw_ops {
 393         void (*phy_errata)(struct mv_host_priv *hpriv, void __iomem *mmio,
 394                            unsigned int port);
 395         void (*enable_leds)(struct mv_host_priv *hpriv, void __iomem *mmio);
 396         void (*read_preamp)(struct mv_host_priv *hpriv, int idx,
 397                            void __iomem *mmio);
 398         int (*reset_hc)(struct mv_host_priv *hpriv, void __iomem *mmio,
 399                         unsigned int n_hc);
 400         void (*reset_flash)(struct mv_host_priv *hpriv, void __iomem *mmio);
 401         void (*reset_bus)(struct pci_dev *pdev, void __iomem *mmio);
 402 };
 403
 404 struct mv_host_priv {
 405         u32                     hp_flags;
 406         struct mv_port_signal   signal[8];
 407         const struct mv_hw_ops  *ops;
 408 };
 409
 410 static void mv_irq_clear(struct ata_port *ap);
 411 static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
 412 static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
 413 static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
 414 static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
 415 static int mv_port_start(struct ata_port *ap);
 416 static void mv_port_stop(struct ata_port *ap);
 417 static void mv_qc_prep(struct ata_queued_cmd *qc);
 418 static void mv_qc_prep_iie(struct ata_queued_cmd *qc);
 419 static unsigned int mv_qc_issue(struct ata_queued_cmd *qc);
 420 static void mv_error_handler(struct ata_port *ap);
 421 static void mv_post_int_cmd(struct ata_queued_cmd *qc);
 422 static void mv_eh_freeze(struct ata_port *ap);
 423 static void mv_eh_thaw(struct ata_port *ap);
 424 static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 425
 426 static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
 427                            unsigned int port);
 428 static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
 429 static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
 430                            void __iomem *mmio);
 431 static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
 432                         unsigned int n_hc);
 433 static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
 434 static void mv5_reset_bus(struct pci_dev *pdev, void __iomem *mmio);
 435
 436 static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
 437                            unsigned int port);
 438 static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio);
 439 static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
 440                            void __iomem *mmio);
 441 static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
 442                         unsigned int n_hc);
 443 static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio);
 444 static void mv_reset_pci_bus(struct pci_dev *pdev, void __iomem *mmio);
 445 static void mv_channel_reset(struct mv_host_priv *hpriv, void __iomem *mmio,
 446                              unsigned int port_no);
 447
 448 static struct scsi_host_template mv5_sht = {
 449         .module                 = THIS_MODULE,
 450         .name                   = DRV_NAME,
 451         .ioctl                  = ata_scsi_ioctl,
 452         .queuecommand           = ata_scsi_queuecmd,
 453         .can_queue              = ATA_DEF_QUEUE,
 454         .this_id                = ATA_SHT_THIS_ID,
 455         .sg_tablesize           = MV_MAX_SG_CT / 2,
 456         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
 457         .emulated               = ATA_SHT_EMULATED,
 458         .use_clustering         = 1,
 459         .proc_name              = DRV_NAME,
 460         .dma_boundary           = MV_DMA_BOUNDARY,
 461         .slave_configure        = ata_scsi_slave_config,
 462         .slave_destroy          = ata_scsi_slave_destroy,
 463         .bios_param             = ata_std_bios_param,
 464 };
 465
 466 static struct scsi_host_template mv6_sht = {
 467         .module                 = THIS_MODULE,
 468         .name                   = DRV_NAME,
 469         .ioctl                  = ata_scsi_ioctl,
 470         .queuecommand           = ata_scsi_queuecmd,
 471         .can_queue              = ATA_DEF_QUEUE,
 472         .this_id                = ATA_SHT_THIS_ID,
 473         .sg_tablesize           = MV_MAX_SG_CT / 2,
 474         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
 475         .emulated               = ATA_SHT_EMULATED,
 476         .use_clustering         = 1,
 477         .proc_name              = DRV_NAME,
 478         .dma_boundary           = MV_DMA_BOUNDARY,
 479         .slave_configure        = ata_scsi_slave_config,
 480         .slave_destroy          = ata_scsi_slave_destroy,
 481         .bios_param             = ata_std_bios_param,
 482 };
 483
 484 static const struct ata_port_operations mv5_ops = {
 485         .tf_load                = ata_tf_load,
 486         .tf_read                = ata_tf_read,
 487         .check_status           = ata_check_status,
 488         .exec_command           = ata_exec_command,
 489         .dev_select             = ata_std_dev_select,
 490
 491         .cable_detect           = ata_cable_sata,
 492
 493         .qc_prep                = mv_qc_prep,
 494         .qc_issue               = mv_qc_issue,
 495         .data_xfer              = ata_data_xfer,
 496
 497         .irq_clear              = mv_irq_clear,
 498         .irq_on                 = ata_irq_on,
 499
 500         .error_handler          = mv_error_handler,
 501         .post_internal_cmd      = mv_post_int_cmd,
 502         .freeze                 = mv_eh_freeze,
 503         .thaw                   = mv_eh_thaw,
 504
 505         .scr_read               = mv5_scr_read,
 506         .scr_write              = mv5_scr_write,
 507
 508         .port_start             = mv_port_start,
 509         .port_stop              = mv_port_stop,
 510 };
 511
 512 static const struct ata_port_operations mv6_ops = {
 513         .tf_load                = ata_tf_load,
 514         .tf_read                = ata_tf_read,
 515         .check_status           = ata_check_status,
 516         .exec_command           = ata_exec_command,
 517         .dev_select             = ata_std_dev_select,
 518
 519         .cable_detect           = ata_cable_sata,
 520
 521         .qc_prep                = mv_qc_prep,
 522         .qc_issue               = mv_qc_issue,
 523         .data_xfer              = ata_data_xfer,
 524
 525         .irq_clear              = mv_irq_clear,
 526         .irq_on                 = ata_irq_on,
 527
 528         .error_handler          = mv_error_handler,
 529         .post_internal_cmd      = mv_post_int_cmd,
 530         .freeze                 = mv_eh_freeze,
 531         .thaw                   = mv_eh_thaw,
 532
 533         .scr_read               = mv_scr_read,
 534         .scr_write              = mv_scr_write,
 535
 536         .port_start             = mv_port_start,
 537         .port_stop              = mv_port_stop,
 538 };
 539
 540 static const struct ata_port_operations mv_iie_ops = {
 541         .tf_load                = ata_tf_load,
 542         .tf_read                = ata_tf_read,
 543         .check_status           = ata_check_status,
 544         .exec_command           = ata_exec_command,
 545         .dev_select             = ata_std_dev_select,
 546
 547         .cable_detect           = ata_cable_sata,
 548
 549         .qc_prep                = mv_qc_prep_iie,
 550         .qc_issue               = mv_qc_issue,
 551         .data_xfer              = ata_data_xfer,
 552
 553         .irq_clear              = mv_irq_clear,
 554         .irq_on                 = ata_irq_on,
 555
 556         .error_handler          = mv_error_handler,
 557         .post_internal_cmd      = mv_post_int_cmd,
 558         .freeze                 = mv_eh_freeze,
 559         .thaw                   = mv_eh_thaw,
 560
 561         .scr_read               = mv_scr_read,
 562         .scr_write              = mv_scr_write,
 563
 564         .port_start             = mv_port_start,
 565         .port_stop              = mv_port_stop,
 566 };
 567
 568 static const struct ata_port_info mv_port_info[] = {
 569         {  /* chip_504x */
 570                 .flags          = MV_COMMON_FLAGS,
 571                 .pio_mask       = 0x1f, /* pio0-4 */
 572                 .udma_mask      = ATA_UDMA6,
 573                 .port_ops       = &mv5_ops,
 574         },
 575         {  /* chip_508x */
 576                 .flags          = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
 577                 .pio_mask       = 0x1f, /* pio0-4 */
 578                 .udma_mask      = ATA_UDMA6,
 579                 .port_ops       = &mv5_ops,
 580         },
 581         {  /* chip_5080 */
 582                 .flags          = MV_COMMON_FLAGS | MV_FLAG_DUAL_HC,
 583                 .pio_mask       = 0x1f, /* pio0-4 */
 584                 .udma_mask      = ATA_UDMA6,
 585                 .port_ops       = &mv5_ops,
 586         },
 587         {  /* chip_604x */
 588                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS,
 589                 .pio_mask       = 0x1f, /* pio0-4 */
 590                 .udma_mask      = ATA_UDMA6,
 591                 .port_ops       = &mv6_ops,
 592         },
 593         {  /* chip_608x */
 594                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS |
 595                                   MV_FLAG_DUAL_HC,
 596                 .pio_mask       = 0x1f, /* pio0-4 */
 597                 .udma_mask      = ATA_UDMA6,
 598                 .port_ops       = &mv6_ops,
 599         },
 600         {  /* chip_6042 */
 601                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS,
 602                 .pio_mask       = 0x1f, /* pio0-4 */
 603                 .udma_mask      = ATA_UDMA6,
 604                 .port_ops       = &mv_iie_ops,
 605         },
 606         {  /* chip_7042 */
 607                 .flags          = MV_COMMON_FLAGS | MV_6XXX_FLAGS,
 608                 .pio_mask       = 0x1f, /* pio0-4 */
 609                 .udma_mask      = ATA_UDMA6,
 610                 .port_ops       = &mv_iie_ops,
 611         },
 612 };
 613
 614 static const struct pci_device_id mv_pci_tbl[] = {
 615         { PCI_VDEVICE(MARVELL, 0x5040), chip_504x },
 616         { PCI_VDEVICE(MARVELL, 0x5041), chip_504x },
 617         { PCI_VDEVICE(MARVELL, 0x5080), chip_5080 },
 618         { PCI_VDEVICE(MARVELL, 0x5081), chip_508x },
 619         /* RocketRAID 1740/174x have different identifiers */
 620         { PCI_VDEVICE(TTI, 0x1740), chip_508x },
 621         { PCI_VDEVICE(TTI, 0x1742), chip_508x },
 622
 623         { PCI_VDEVICE(MARVELL, 0x6040), chip_604x },
 624         { PCI_VDEVICE(MARVELL, 0x6041), chip_604x },
 625         { PCI_VDEVICE(MARVELL, 0x6042), chip_6042 },
 626         { PCI_VDEVICE(MARVELL, 0x6080), chip_608x },
 627         { PCI_VDEVICE(MARVELL, 0x6081), chip_608x },
 628
 629         { PCI_VDEVICE(ADAPTEC2, 0x0241), chip_604x },
 630
 631         /* Adaptec 1430SA */
 632         { PCI_VDEVICE(ADAPTEC2, 0x0243), chip_7042 },
 633
 634         { PCI_VDEVICE(TTI, 0x2310), chip_7042 },
 635
 636         /* add Marvell 7042 support */
 637         { PCI_VDEVICE(MARVELL, 0x7042), chip_7042 },
 638
 639         { }                     /* terminate list */
 640 };
 641
 642 static struct pci_driver mv_pci_driver = {
 643         .name                   = DRV_NAME,
 644         .id_table               = mv_pci_tbl,
 645         .probe                  = mv_init_one,
 646         .remove                 = ata_pci_remove_one,
 647 };
 648
 649 static const struct mv_hw_ops mv5xxx_ops = {
 650         .phy_errata             = mv5_phy_errata,
 651         .enable_leds            = mv5_enable_leds,
 652         .read_preamp            = mv5_read_preamp,
 653         .reset_hc               = mv5_reset_hc,
 654         .reset_flash            = mv5_reset_flash,
 655         .reset_bus              = mv5_reset_bus,
 656 };
 657
 658 static const struct mv_hw_ops mv6xxx_ops = {
 659         .phy_errata             = mv6_phy_errata,
 660         .enable_leds            = mv6_enable_leds,
 661         .read_preamp            = mv6_read_preamp,
 662         .reset_hc               = mv6_reset_hc,
 663         .reset_flash            = mv6_reset_flash,
 664         .reset_bus              = mv_reset_pci_bus,
 665 };
 666
 667 /*
 668  * module options
 669  */
 670 static int msi;       /* Use PCI msi; either zero (off, default) or non-zero */
 671
 672
 673 /* move to PCI layer or libata core? */
 674 static int pci_go_64(struct pci_dev *pdev)
 675 {
 676         int rc;
 677
 678         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)) {
 679                 rc = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
 680                 if (rc) {
 681                         rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
 682                         if (rc) {
 683                                 dev_printk(KERN_ERR, &pdev->dev,
 684                                            "64-bit DMA enable failed\n");
 685                                 return rc;
 686                         }
 687                 }
 688         } else {
 689                 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
 690                 if (rc) {
 691                         dev_printk(KERN_ERR, &pdev->dev,
 692                                    "32-bit DMA enable failed\n");
 693                         return rc;
 694                 }
 695                 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
 696                 if (rc) {
 697                         dev_printk(KERN_ERR, &pdev->dev,
 698                                    "32-bit consistent DMA enable failed\n");
 699                         return rc;
 700                 }
 701         }
 702
 703         return rc;
 704 }
 705
 706 /*
 707  * Functions
 708  */
 709
 710 static inline void writelfl(unsigned long data, void __iomem *addr)
 711 {
 712         writel(data, addr);
 713         (void) readl(addr);     /* flush to avoid PCI posted write */
 714 }
 715
 716 static inline void __iomem *mv_hc_base(void __iomem *base, unsigned int hc)
 717 {
 718         return (base + MV_SATAHC0_REG_BASE + (hc * MV_SATAHC_REG_SZ));
 719 }
 720
 721 static inline unsigned int mv_hc_from_port(unsigned int port)
 722 {
 723         return port >> MV_PORT_HC_SHIFT;
 724 }
 725
 726 static inline unsigned int mv_hardport_from_port(unsigned int port)
 727 {
 728         return port & MV_PORT_MASK;
 729 }
 730
 731 static inline void __iomem *mv_hc_base_from_port(void __iomem *base,
 732                                                  unsigned int port)
 733 {
 734         return mv_hc_base(base, mv_hc_from_port(port));
 735 }
 736
 737 static inline void __iomem *mv_port_base(void __iomem *base, unsigned int port)
 738 {
 739         return  mv_hc_base_from_port(base, port) +
 740                 MV_SATAHC_ARBTR_REG_SZ +
 741                 (mv_hardport_from_port(port) * MV_PORT_REG_SZ);
 742 }
 743
 744 static inline void __iomem *mv_ap_base(struct ata_port *ap)
 745 {
 746         return mv_port_base(ap->host->iomap[MV_PRIMARY_BAR], ap->port_no);
 747 }
 748
 749 static inline int mv_get_hc_count(unsigned long port_flags)
 750 {
 751         return ((port_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
 752 }
 753
 754 static void mv_irq_clear(struct ata_port *ap)
 755 {
 756 }
 757
 758 static void mv_set_edma_ptrs(void __iomem *port_mmio,
 759                              struct mv_host_priv *hpriv,
 760                              struct mv_port_priv *pp)
 761 {
 762         u32 index;
 763
 764         /*
 765          * initialize request queue
 766          */
 767         index = (pp->req_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_REQ_Q_PTR_SHIFT;
 768
 769         WARN_ON(pp->crqb_dma & 0x3ff);
 770         writel((pp->crqb_dma >> 16) >> 16, port_mmio + EDMA_REQ_Q_BASE_HI_OFS);
 771         writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | index,
 772                  port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
 773
 774         if (hpriv->hp_flags & MV_HP_ERRATA_XX42A0)
 775                 writelfl((pp->crqb_dma & 0xffffffff) | index,
 776                          port_mmio + EDMA_REQ_Q_OUT_PTR_OFS);
 777         else
 778                 writelfl(index, port_mmio + EDMA_REQ_Q_OUT_PTR_OFS);
 779
 780         /*
 781          * initialize response queue
 782          */
 783         index = (pp->resp_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_RSP_Q_PTR_SHIFT;
 784
 785         WARN_ON(pp->crpb_dma & 0xff);
 786         writel((pp->crpb_dma >> 16) >> 16, port_mmio + EDMA_RSP_Q_BASE_HI_OFS);
 787
 788         if (hpriv->hp_flags & MV_HP_ERRATA_XX42A0)
 789                 writelfl((pp->crpb_dma & 0xffffffff) | index,
 790                          port_mmio + EDMA_RSP_Q_IN_PTR_OFS);
 791         else
 792                 writelfl(index, port_mmio + EDMA_RSP_Q_IN_PTR_OFS);
 793
 794         writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) | index,
 795                  port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
 796 }
 797
 798 /**
 799  *      mv_start_dma - Enable eDMA engine
 800  *      @base: port base address
 801  *      @pp: port private data
 802  *
 803  *      Verify the local cache of the eDMA state is accurate with a
 804  *      WARN_ON.
 805  *
 806  *      LOCKING:
 807  *      Inherited from caller.
 808  */
 809 static void mv_start_dma(void __iomem *base, struct mv_host_priv *hpriv,
 810                          struct mv_port_priv *pp)
 811 {
 812         if (!(pp->pp_flags & MV_PP_FLAG_EDMA_EN)) {
 813                 /* clear EDMA event indicators, if any */
 814                 writelfl(0, base + EDMA_ERR_IRQ_CAUSE_OFS);
 815
 816                 mv_set_edma_ptrs(base, hpriv, pp);
 817
 818                 writelfl(EDMA_EN, base + EDMA_CMD_OFS);
 819                 pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
 820         }
 821         WARN_ON(!(EDMA_EN & readl(base + EDMA_CMD_OFS)));
 822 }
 823
 824 /**
 825  *      __mv_stop_dma - Disable eDMA engine
 826  *      @ap: ATA channel to manipulate
 827  *
 828  *      Verify the local cache of the eDMA state is accurate with a
 829  *      WARN_ON.
 830  *
 831  *      LOCKING:
 832  *      Inherited from caller.
 833  */
 834 static int __mv_stop_dma(struct ata_port *ap)
 835 {
 836         void __iomem *port_mmio = mv_ap_base(ap);
 837         struct mv_port_priv *pp = ap->private_data;
 838         u32 reg;
 839         int i, err = 0;
 840
 841         if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
 842                 /* Disable EDMA if active.   The disable bit auto clears.
 843                  */
 844                 writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
 845                 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
 846         } else {
 847                 WARN_ON(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
 848         }
 849
 850         /* now properly wait for the eDMA to stop */
 851         for (i = 1000; i > 0; i--) {
 852                 reg = readl(port_mmio + EDMA_CMD_OFS);
 853                 if (!(reg & EDMA_EN))
 854                         break;
 855
 856                 udelay(100);
 857         }
 858
 859         if (reg & EDMA_EN) {
 860                 ata_port_printk(ap, KERN_ERR, "Unable to stop eDMA\n");
 861                 err = -EIO;
 862         }
 863
 864         return err;
 865 }
 866
 867 static int mv_stop_dma(struct ata_port *ap)
 868 {
 869         unsigned long flags;
 870         int rc;
 871
 872         spin_lock_irqsave(&ap->host->lock, flags);
 873         rc = __mv_stop_dma(ap);
 874         spin_unlock_irqrestore(&ap->host->lock, flags);
 875
 876         return rc;
 877 }
 878
 879 #ifdef ATA_DEBUG
 880 static void mv_dump_mem(void __iomem *start, unsigned bytes)
 881 {
 882         int b, w;
 883         for (b = 0; b < bytes; ) {
 884                 DPRINTK("%p: ", start + b);
 885                 for (w = 0; b < bytes && w < 4; w++) {
 886                         printk("%08x ", readl(start + b));
 887                         b += sizeof(u32);
 888                 }
 889                 printk("\n");
 890         }
 891 }
 892 #endif
 893
 894 static void mv_dump_pci_cfg(struct pci_dev *pdev, unsigned bytes)
 895 {
 896 #ifdef ATA_DEBUG
 897         int b, w;
 898         u32 dw;
 899         for (b = 0; b < bytes; ) {
 900                 DPRINTK("%02x: ", b);
 901                 for (w = 0; b < bytes && w < 4; w++) {
 902                         (void) pci_read_config_dword(pdev, b, &dw);
 903                         printk("%08x ", dw);
 904                         b += sizeof(u32);
 905                 }
 906                 printk("\n");
 907         }
 908 #endif
 909 }
 910 static void mv_dump_all_regs(void __iomem *mmio_base, int port,
 911                              struct pci_dev *pdev)
 912 {
 913 #ifdef ATA_DEBUG
 914         void __iomem *hc_base = mv_hc_base(mmio_base,
 915                                            port >> MV_PORT_HC_SHIFT);
 916         void __iomem *port_base;
 917         int start_port, num_ports, p, start_hc, num_hcs, hc;
 918
 919         if (0 > port) {
 920                 start_hc = start_port = 0;
 921                 num_ports = 8;          /* shld be benign for 4 port devs */
 922                 num_hcs = 2;
 923         } else {
 924                 start_hc = port >> MV_PORT_HC_SHIFT;
 925                 start_port = port;
 926                 num_ports = num_hcs = 1;
 927         }
 928         DPRINTK("All registers for port(s) %u-%u:\n", start_port,
 929                 num_ports > 1 ? num_ports - 1 : start_port);
 930
 931         if (NULL != pdev) {
 932                 DPRINTK("PCI config space regs:\n");
 933                 mv_dump_pci_cfg(pdev, 0x68);
 934         }
 935         DPRINTK("PCI regs:\n");
 936         mv_dump_mem(mmio_base+0xc00, 0x3c);
 937         mv_dump_mem(mmio_base+0xd00, 0x34);
 938         mv_dump_mem(mmio_base+0xf00, 0x4);
 939         mv_dump_mem(mmio_base+0x1d00, 0x6c);
 940         for (hc = start_hc; hc < start_hc + num_hcs; hc++) {
 941                 hc_base = mv_hc_base(mmio_base, hc);
 942                 DPRINTK("HC regs (HC %i):\n", hc);
 943                 mv_dump_mem(hc_base, 0x1c);
 944         }
 945         for (p = start_port; p < start_port + num_ports; p++) {
 946                 port_base = mv_port_base(mmio_base, p);
 947                 DPRINTK("EDMA regs (port %i):\n", p);
 948                 mv_dump_mem(port_base, 0x54);
 949                 DPRINTK("SATA regs (port %i):\n", p);
 950                 mv_dump_mem(port_base+0x300, 0x60);
 951         }
 952 #endif
 953 }
 954
 955 static unsigned int mv_scr_offset(unsigned int sc_reg_in)
 956 {
 957         unsigned int ofs;
 958
 959         switch (sc_reg_in) {
 960         case SCR_STATUS:
 961         case SCR_CONTROL:
 962         case SCR_ERROR:
 963                 ofs = SATA_STATUS_OFS + (sc_reg_in * sizeof(u32));
 964                 break;
 965         case SCR_ACTIVE:
 966                 ofs = SATA_ACTIVE_OFS;   /* active is not with the others */
 967                 break;
 968         default:
 969                 ofs = 0xffffffffU;
 970                 break;
 971         }
 972         return ofs;
 973 }
 974
 975 static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
 976 {
 977         unsigned int ofs = mv_scr_offset(sc_reg_in);
 978
 979         if (ofs != 0xffffffffU) {
 980                 *val = readl(mv_ap_base(ap) + ofs);
 981                 return 0;
 982         } else
 983                 return -EINVAL;
 984 }
 985
 986 static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
 987 {
 988         unsigned int ofs = mv_scr_offset(sc_reg_in);
 989
 990         if (ofs != 0xffffffffU) {
 991                 writelfl(val, mv_ap_base(ap) + ofs);
 992                 return 0;
 993         } else
 994                 return -EINVAL;
 995 }
 996
 997 static void mv_edma_cfg(struct ata_port *ap, struct mv_host_priv *hpriv,
 998                         void __iomem *port_mmio)
 999 {
1000         u32 cfg = readl(port_mmio + EDMA_CFG_OFS);
1001
1002         /* set up non-NCQ EDMA configuration */
1003         cfg &= ~(1 << 9);       /* disable eQue */
1004
1005         if (IS_GEN_I(hpriv)) {
1006                 cfg &= ~0x1f;           /* clear queue depth */
1007                 cfg |= (1 << 8);        /* enab config burst size mask */
1008         }
1009
1010         else if (IS_GEN_II(hpriv)) {
1011                 cfg &= ~0x1f;           /* clear queue depth */
1012                 cfg |= EDMA_CFG_RD_BRST_EXT | EDMA_CFG_WR_BUFF_LEN;
1013                 cfg &= ~(EDMA_CFG_NCQ | EDMA_CFG_NCQ_GO_ON_ERR); /* clear NCQ */
1014         }
1015
1016         else if (IS_GEN_IIE(hpriv)) {
1017                 cfg |= (1 << 23);       /* do not mask PM field in rx'd FIS */
1018                 cfg |= (1 << 22);       /* enab 4-entry host queue cache */
1019                 cfg &= ~(1 << 19);      /* dis 128-entry queue (for now?) */
1020                 cfg |= (1 << 18);       /* enab early completion */
1021                 cfg |= (1 << 17);       /* enab cut-through (dis stor&forwrd) */
1022                 cfg &= ~(1 << 16);      /* dis FIS-based switching (for now) */
1023                 cfg &= ~(EDMA_CFG_NCQ); /* clear NCQ */
1024         }
1025
1026         writelfl(cfg, port_mmio + EDMA_CFG_OFS);
1027 }
1028
1029 /**
1030  *      mv_port_start - Port specific init/start routine.
1031  *      @ap: ATA channel to manipulate
1032  *
1033  *      Allocate and point to DMA memory, init port private memory,
1034  *      zero indices.
1035  *
1036  *      LOCKING:
1037  *      Inherited from caller.
1038  */
1039 static int mv_port_start(struct ata_port *ap)
1040 {
1041         struct device *dev = ap->host->dev;
1042         struct mv_host_priv *hpriv = ap->host->private_data;
1043         struct mv_port_priv *pp;
1044         void __iomem *port_mmio = mv_ap_base(ap);
1045         void *mem;
1046         dma_addr_t mem_dma;
1047         unsigned long flags;
1048         int rc;
1049
1050         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
1051         if (!pp)
1052                 return -ENOMEM;
1053
1054         mem = dmam_alloc_coherent(dev, MV_PORT_PRIV_DMA_SZ, &mem_dma,
1055                                   GFP_KERNEL);
1056         if (!mem)
1057                 return -ENOMEM;
1058         memset(mem, 0, MV_PORT_PRIV_DMA_SZ);
1059
1060         rc = ata_pad_alloc(ap, dev);
1061         if (rc)
1062                 return rc;
1063
1064         /* First item in chunk of DMA memory:
1065          * 32-slot command request table (CRQB), 32 bytes each in size
1066          */
1067         pp->crqb = mem;
1068         pp->crqb_dma = mem_dma;
1069         mem += MV_CRQB_Q_SZ;
1070         mem_dma += MV_CRQB_Q_SZ;
1071
1072         /* Second item:
1073          * 32-slot command response table (CRPB), 8 bytes each in size
1074          */
1075         pp->crpb = mem;
1076         pp->crpb_dma = mem_dma;
1077         mem += MV_CRPB_Q_SZ;
1078         mem_dma += MV_CRPB_Q_SZ;
1079
1080         /* Third item:
1081          * Table of scatter-gather descriptors (ePRD), 16 bytes each
1082          */
1083         pp->sg_tbl = mem;
1084         pp->sg_tbl_dma = mem_dma;
1085
1086         spin_lock_irqsave(&ap->host->lock, flags);
1087
1088         mv_edma_cfg(ap, hpriv, port_mmio);
1089
1090         mv_set_edma_ptrs(port_mmio, hpriv, pp);
1091
1092         spin_unlock_irqrestore(&ap->host->lock, flags);
1093
1094         /* Don't turn on EDMA here...do it before DMA commands only.  Else
1095          * we'll be unable to send non-data, PIO, etc due to restricted access
1096          * to shadow regs.
1097          */
1098         ap->private_data = pp;
1099         return 0;
1100 }
1101
1102 /**
1103  *      mv_port_stop - Port specific cleanup/stop routine.
1104  *      @ap: ATA channel to manipulate
1105  *
1106  *      Stop DMA, cleanup port memory.
1107  *
1108  *      LOCKING:
1109  *      This routine uses the host lock to protect the DMA stop.
1110  */
1111 static void mv_port_stop(struct ata_port *ap)
1112 {
1113         mv_stop_dma(ap);
1114 }
1115
1116 /**
1117  *      mv_fill_sg - Fill out the Marvell ePRD (scatter gather) entries
1118  *      @qc: queued command whose SG list to source from
1119  *
1120  *      Populate the SG list and mark the last entry.
1121  *
1122  *      LOCKING:
1123  *      Inherited from caller.
1124  */
1125 static void mv_fill_sg(struct ata_queued_cmd *qc)
1126 {
1127         struct mv_port_priv *pp = qc->ap->private_data;
1128         struct scatterlist *sg;
1129         struct mv_sg *mv_sg, *last_sg = NULL;
1130
1131         mv_sg = pp->sg_tbl;
1132         ata_for_each_sg(sg, qc) {
1133                 dma_addr_t addr = sg_dma_address(sg);
1134                 u32 sg_len = sg_dma_len(sg);
1135
1136                 while (sg_len) {
1137                         u32 offset = addr & 0xffff;
1138                         u32 len = sg_len;
1139
1140                         if ((offset + sg_len > 0x10000))
1141                                 len = 0x10000 - offset;
1142
1143                         mv_sg->addr = cpu_to_le32(addr & 0xffffffff);
1144                         mv_sg->addr_hi = cpu_to_le32((addr >> 16) >> 16);
1145                         mv_sg->flags_size = cpu_to_le32(len & 0xffff);
1146
1147                         sg_len -= len;
1148                         addr += len;
1149
1150                         last_sg = mv_sg;
1151                         mv_sg++;
1152                 }
1153         }
1154
1155         if (likely(last_sg))
1156                 last_sg->flags_size |= cpu_to_le32(EPRD_FLAG_END_OF_TBL);
1157 }
1158
1159 static void mv_crqb_pack_cmd(__le16 *cmdw, u8 data, u8 addr, unsigned last)
1160 {
1161         u16 tmp = data | (addr << CRQB_CMD_ADDR_SHIFT) | CRQB_CMD_CS |
1162                 (last ? CRQB_CMD_LAST : 0);
1163         *cmdw = cpu_to_le16(tmp);
1164 }
1165
1166 /**
1167  *      mv_qc_prep - Host specific command preparation.
1168  *      @qc: queued command to prepare
1169  *
1170  *      This routine simply redirects to the general purpose routine
1171  *      if command is not DMA.  Else, it handles prep of the CRQB
1172  *      (command request block), does some sanity checking, and calls
1173  *      the SG load routine.
1174  *
1175  *      LOCKING:
1176  *      Inherited from caller.
1177  */
1178 static void mv_qc_prep(struct ata_queued_cmd *qc)
1179 {
1180         struct ata_port *ap = qc->ap;
1181         struct mv_port_priv *pp = ap->private_data;
1182         __le16 *cw;
1183         struct ata_taskfile *tf;
1184         u16 flags = 0;
1185         unsigned in_index;
1186
1187         if (qc->tf.protocol != ATA_PROT_DMA)
1188                 return;
1189
1190         /* Fill in command request block
1191          */
1192         if (!(qc->tf.flags & ATA_TFLAG_WRITE))
1193                 flags |= CRQB_FLAG_READ;
1194         WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
1195         flags |= qc->tag << CRQB_TAG_SHIFT;
1196         flags |= qc->tag << CRQB_IOID_SHIFT;    /* 50xx appears to ignore this*/
1197
1198         /* get current queue index from software */
1199         in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
1200
1201         pp->crqb[in_index].sg_addr =
1202                 cpu_to_le32(pp->sg_tbl_dma & 0xffffffff);
1203         pp->crqb[in_index].sg_addr_hi =
1204                 cpu_to_le32((pp->sg_tbl_dma >> 16) >> 16);
1205         pp->crqb[in_index].ctrl_flags = cpu_to_le16(flags);
1206
1207         cw = &pp->crqb[in_index].ata_cmd[0];
1208         tf = &qc->tf;
1209
1210         /* Sadly, the CRQB cannot accomodate all registers--there are
1211          * only 11 bytes...so we must pick and choose required
1212          * registers based on the command.  So, we drop feature and
1213          * hob_feature for [RW] DMA commands, but they are needed for
1214          * NCQ.  NCQ will drop hob_nsect.
1215          */
1216         switch (tf->command) {
1217         case ATA_CMD_READ:
1218         case ATA_CMD_READ_EXT:
1219         case ATA_CMD_WRITE:
1220         case ATA_CMD_WRITE_EXT:
1221         case ATA_CMD_WRITE_FUA_EXT:
1222                 mv_crqb_pack_cmd(cw++, tf->hob_nsect, ATA_REG_NSECT, 0);
1223                 break;
1224 #ifdef LIBATA_NCQ               /* FIXME: remove this line when NCQ added */
1225         case ATA_CMD_FPDMA_READ:
1226         case ATA_CMD_FPDMA_WRITE:
1227                 mv_crqb_pack_cmd(cw++, tf->hob_feature, ATA_REG_FEATURE, 0);
1228                 mv_crqb_pack_cmd(cw++, tf->feature, ATA_REG_FEATURE, 0);
1229                 break;
1230 #endif                          /* FIXME: remove this line when NCQ added */
1231         default:
1232                 /* The only other commands EDMA supports in non-queued and
1233                  * non-NCQ mode are: [RW] STREAM DMA and W DMA FUA EXT, none
1234                  * of which are defined/used by Linux.  If we get here, this
1235                  * driver needs work.
1236                  *
1237                  * FIXME: modify libata to give qc_prep a return value and
1238                  * return error here.
1239                  */
1240                 BUG_ON(tf->command);
1241                 break;
1242         }
1243         mv_crqb_pack_cmd(cw++, tf->nsect, ATA_REG_NSECT, 0);
1244         mv_crqb_pack_cmd(cw++, tf->hob_lbal, ATA_REG_LBAL, 0);
1245         mv_crqb_pack_cmd(cw++, tf->lbal, ATA_REG_LBAL, 0);
1246         mv_crqb_pack_cmd(cw++, tf->hob_lbam, ATA_REG_LBAM, 0);
1247         mv_crqb_pack_cmd(cw++, tf->lbam, ATA_REG_LBAM, 0);
1248         mv_crqb_pack_cmd(cw++, tf->hob_lbah, ATA_REG_LBAH, 0);
1249         mv_crqb_pack_cmd(cw++, tf->lbah, ATA_REG_LBAH, 0);
1250         mv_crqb_pack_cmd(cw++, tf->device, ATA_REG_DEVICE, 0);
1251         mv_crqb_pack_cmd(cw++, tf->command, ATA_REG_CMD, 1);    /* last */
1252
1253         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1254                 return;
1255         mv_fill_sg(qc);
1256 }
1257
1258 /**
1259  *      mv_qc_prep_iie - Host specific command preparation.
1260  *      @qc: queued command to prepare
1261  *
1262  *      This routine simply redirects to the general purpose routine
1263  *      if command is not DMA.  Else, it handles prep of the CRQB
1264  *      (command request block), does some sanity checking, and calls
1265  *      the SG load routine.
1266  *
1267  *      LOCKING:
1268  *      Inherited from caller.
1269  */
1270 static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
1271 {
1272         struct ata_port *ap = qc->ap;
1273         struct mv_port_priv *pp = ap->private_data;
1274         struct mv_crqb_iie *crqb;
1275         struct ata_taskfile *tf;
1276         unsigned in_index;
1277         u32 flags = 0;
1278
1279         if (qc->tf.protocol != ATA_PROT_DMA)
1280                 return;
1281
1282         /* Fill in Gen IIE command request block
1283          */
1284         if (!(qc->tf.flags & ATA_TFLAG_WRITE))
1285                 flags |= CRQB_FLAG_READ;
1286
1287         WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
1288         flags |= qc->tag << CRQB_TAG_SHIFT;
1289         flags |= qc->tag << CRQB_IOID_SHIFT;    /* "I/O Id" is -really-
1290                                                    what we use as our tag */
1291
1292         /* get current queue index from software */
1293         in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
1294
1295         crqb = (struct mv_crqb_iie *) &pp->crqb[in_index];
1296         crqb->addr = cpu_to_le32(pp->sg_tbl_dma & 0xffffffff);
1297         crqb->addr_hi = cpu_to_le32((pp->sg_tbl_dma >> 16) >> 16);
1298         crqb->flags = cpu_to_le32(flags);
1299
1300         tf = &qc->tf;
1301         crqb->ata_cmd[0] = cpu_to_le32(
1302                         (tf->command << 16) |
1303                         (tf->feature << 24)
1304                 );
1305         crqb->ata_cmd[1] = cpu_to_le32(
1306                         (tf->lbal << 0) |
1307                         (tf->lbam << 8) |
1308                         (tf->lbah << 16) |
1309                         (tf->device << 24)
1310                 );
1311         crqb->ata_cmd[2] = cpu_to_le32(
1312                         (tf->hob_lbal << 0) |
1313                         (tf->hob_lbam << 8) |
1314                         (tf->hob_lbah << 16) |
1315                         (tf->hob_feature << 24)
1316                 );
1317         crqb->ata_cmd[3] = cpu_to_le32(
1318                         (tf->nsect << 0) |
1319                         (tf->hob_nsect << 8)
1320                 );
1321
1322         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1323                 return;
1324         mv_fill_sg(qc);
1325 }
1326
1327 /**
1328  *      mv_qc_issue - Initiate a command to the host
1329  *      @qc: queued command to start
1330  *
1331  *      This routine simply redirects to the general purpose routine
1332  *      if command is not DMA.  Else, it sanity checks our local
1333  *      caches of the request producer/consumer indices then enables
1334  *      DMA and bumps the request producer index.
1335  *
1336  *      LOCKING:
1337  *      Inherited from caller.
1338  */
1339 static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
1340 {
1341         struct ata_port *ap = qc->ap;
1342         void __iomem *port_mmio = mv_ap_base(ap);
1343         struct mv_port_priv *pp = ap->private_data;
1344         struct mv_host_priv *hpriv = ap->host->private_data;
1345         u32 in_index;
1346
1347         if (qc->tf.protocol != ATA_PROT_DMA) {
1348                 /* We're about to send a non-EDMA capable command to the
1349                  * port.  Turn off EDMA so there won't be problems accessing
1350                  * shadow block, etc registers.
1351                  */
1352                 __mv_stop_dma(ap);
1353                 return ata_qc_issue_prot(qc);
1354         }
1355
1356         mv_start_dma(port_mmio, hpriv, pp);
1357
1358         in_index = pp->req_idx & MV_MAX_Q_DEPTH_MASK;
1359
1360         /* until we do queuing, the queue should be empty at this point */
1361         WARN_ON(in_index != ((readl(port_mmio + EDMA_REQ_Q_OUT_PTR_OFS)
1362                 >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK));
1363
1364         pp->req_idx++;
1365
1366         in_index = (pp->req_idx & MV_MAX_Q_DEPTH_MASK) << EDMA_REQ_Q_PTR_SHIFT;
1367
1368         /* and write the request in pointer to kick the EDMA to life */
1369         writelfl((pp->crqb_dma & EDMA_REQ_Q_BASE_LO_MASK) | in_index,
1370                  port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
1371
1372         return 0;
1373 }
1374
1375 /**
1376  *      mv_err_intr - Handle error interrupts on the port
1377  *      @ap: ATA channel to manipulate
1378  *      @reset_allowed: bool: 0 == don't trigger from reset here
1379  *
1380  *      In most cases, just clear the interrupt and move on.  However,
1381  *      some cases require an eDMA reset, which is done right before
1382  *      the COMRESET in mv_phy_reset().  The SERR case requires a
1383  *      clear of pending errors in the SATA SERROR register.  Finally,
1384  *      if the port disabled DMA, update our cached copy to match.
1385  *
1386  *      LOCKING:
1387  *      Inherited from caller.
1388  */
1389 static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
1390 {
1391         void __iomem *port_mmio = mv_ap_base(ap);
1392         u32 edma_err_cause, eh_freeze_mask, serr = 0;
1393         struct mv_port_priv *pp = ap->private_data;
1394         struct mv_host_priv *hpriv = ap->host->private_data;
1395         unsigned int edma_enabled = (pp->pp_flags & MV_PP_FLAG_EDMA_EN);
1396         unsigned int action = 0, err_mask = 0;
1397         struct ata_eh_info *ehi = &ap->link.eh_info;
1398
1399         ata_ehi_clear_desc(ehi);
1400
1401         if (!edma_enabled) {
1402                 /* just a guess: do we need to do this? should we
1403                  * expand this, and do it in all cases?
1404                  */
1405                 sata_scr_read(&ap->link, SCR_ERROR, &serr);
1406                 sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
1407         }
1408
1409         edma_err_cause = readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
1410
1411         ata_ehi_push_desc(ehi, "edma_err 0x%08x", edma_err_cause);
1412
1413         /*
1414          * all generations share these EDMA error cause bits
1415          */
1416
1417         if (edma_err_cause & EDMA_ERR_DEV)
1418                 err_mask |= AC_ERR_DEV;
1419         if (edma_err_cause & (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR |
1420                         EDMA_ERR_CRQB_PAR | EDMA_ERR_CRPB_PAR |
1421                         EDMA_ERR_INTRL_PAR)) {
1422                 err_mask |= AC_ERR_ATA_BUS;
1423                 action |= ATA_EH_HARDRESET;
1424                 ata_ehi_push_desc(ehi, "parity error");
1425         }
1426         if (edma_err_cause & (EDMA_ERR_DEV_DCON | EDMA_ERR_DEV_CON)) {
1427                 ata_ehi_hotplugged(ehi);
1428                 ata_ehi_push_desc(ehi, edma_err_cause & EDMA_ERR_DEV_DCON ?
1429                         "dev disconnect" : "dev connect");
1430         }
1431
1432         if (IS_GEN_I(hpriv)) {
1433                 eh_freeze_mask = EDMA_EH_FREEZE_5;
1434
1435                 if (edma_err_cause & EDMA_ERR_SELF_DIS_5) {
1436                         struct mv_port_priv *pp = ap->private_data;
1437                         pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
1438                         ata_ehi_push_desc(ehi, "EDMA self-disable");
1439                 }
1440         } else {
1441                 eh_freeze_mask = EDMA_EH_FREEZE;
1442
1443                 if (edma_err_cause & EDMA_ERR_SELF_DIS) {
1444                         struct mv_port_priv *pp = ap->private_data;
1445                         pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
1446                         ata_ehi_push_desc(ehi, "EDMA self-disable");
1447                 }
1448
1449                 if (edma_err_cause & EDMA_ERR_SERR) {
1450                         sata_scr_read(&ap->link, SCR_ERROR, &serr);
1451                         sata_scr_write_flush(&ap->link, SCR_ERROR, serr);
1452                         err_mask = AC_ERR_ATA_BUS;
1453                         action |= ATA_EH_HARDRESET;
1454                 }
1455         }
1456
1457         /* Clear EDMA now that SERR cleanup done */
1458         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
1459
1460         if (!err_mask) {
1461                 err_mask = AC_ERR_OTHER;
1462                 action |= ATA_EH_HARDRESET;
1463         }
1464
1465         ehi->serror |= serr;
1466         ehi->action |= action;
1467
1468         if (qc)
1469                 qc->err_mask |= err_mask;
1470         else
1471                 ehi->err_mask |= err_mask;
1472
1473         if (edma_err_cause & eh_freeze_mask)
1474                 ata_port_freeze(ap);
1475         else
1476                 ata_port_abort(ap);
1477 }
1478
1479 static void mv_intr_pio(struct ata_port *ap)
1480 {
1481         struct ata_queued_cmd *qc;
1482         u8 ata_status;
1483
1484         /* ignore spurious intr if drive still BUSY */
1485         ata_status = readb(ap->ioaddr.status_addr);
1486         if (unlikely(ata_status & ATA_BUSY))
1487                 return;
1488
1489         /* get active ATA command */
1490         qc = ata_qc_from_tag(ap, ap->link.active_tag);
1491         if (unlikely(!qc))                      /* no active tag */
1492                 return;
1493         if (qc->tf.flags & ATA_TFLAG_POLLING)   /* polling; we don't own qc */
1494                 return;
1495
1496         /* and finally, complete the ATA command */
1497         qc->err_mask |= ac_err_mask(ata_status);
1498         ata_qc_complete(qc);
1499 }
1500
1501 static void mv_intr_edma(struct ata_port *ap)
1502 {
1503         void __iomem *port_mmio = mv_ap_base(ap);
1504         struct mv_host_priv *hpriv = ap->host->private_data;
1505         struct mv_port_priv *pp = ap->private_data;
1506         struct ata_queued_cmd *qc;
1507         u32 out_index, in_index;
1508         bool work_done = false;
1509
1510         /* get h/w response queue pointer */
1511         in_index = (readl(port_mmio + EDMA_RSP_Q_IN_PTR_OFS)
1512                         >> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK;
1513
1514         while (1) {
1515                 u16 status;
1516                 unsigned int tag;
1517
1518                 /* get s/w response queue last-read pointer, and compare */
1519                 out_index = pp->resp_idx & MV_MAX_Q_DEPTH_MASK;
1520                 if (in_index == out_index)
1521                         break;
1522
1523                 /* 50xx: get active ATA command */
1524                 if (IS_GEN_I(hpriv))
1525                         tag = ap->link.active_tag;
1526
1527                 /* Gen II/IIE: get active ATA command via tag, to enable
1528                  * support for queueing.  this works transparently for
1529                  * queued and non-queued modes.
1530                  */
1531                 else if (IS_GEN_II(hpriv))
1532                         tag = (le16_to_cpu(pp->crpb[out_index].id)
1533                                 >> CRPB_IOID_SHIFT_6) & 0x3f;
1534
1535                 else /* IS_GEN_IIE */
1536                         tag = (le16_to_cpu(pp->crpb[out_index].id)
1537                                 >> CRPB_IOID_SHIFT_7) & 0x3f;
1538
1539                 qc = ata_qc_from_tag(ap, tag);
1540
1541                 /* lower 8 bits of status are EDMA_ERR_IRQ_CAUSE_OFS
1542                  * bits (WARNING: might not necessarily be associated
1543                  * with this command), which -should- be clear
1544                  * if all is well
1545                  */
1546                 status = le16_to_cpu(pp->crpb[out_index].flags);
1547                 if (unlikely(status & 0xff)) {
1548                         mv_err_intr(ap, qc);
1549                         return;
1550                 }
1551
1552                 /* and finally, complete the ATA command */
1553                 if (qc) {
1554                         qc->err_mask |=
1555                                 ac_err_mask(status >> CRPB_FLAG_STATUS_SHIFT);
1556                         ata_qc_complete(qc);
1557                 }
1558
1559                 /* advance software response queue pointer, to
1560                  * indicate (after the loop completes) to hardware
1561                  * that we have consumed a response queue entry.
1562                  */
1563                 work_done = true;
1564                 pp->resp_idx++;
1565         }
1566
1567         if (work_done)
1568                 writelfl((pp->crpb_dma & EDMA_RSP_Q_BASE_LO_MASK) |
1569                          (out_index << EDMA_RSP_Q_PTR_SHIFT),
1570                          port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
1571 }
1572
1573 /**
1574  *      mv_host_intr - Handle all interrupts on the given host controller
1575  *      @host: host specific structure
1576  *      @relevant: port error bits relevant to this host controller
1577  *      @hc: which host controller we're to look at
1578  *
1579  *      Read then write clear the HC interrupt status then walk each
1580  *      port connected to the HC and see if it needs servicing.  Port
1581  *      success ints are reported in the HC interrupt status reg, the
1582  *      port error ints are reported in the higher level main
1583  *      interrupt status register and thus are passed in via the
1584  *      'relevant' argument.
1585  *
1586  *      LOCKING:
1587  *      Inherited from caller.
1588  */
1589 static void mv_host_intr(struct ata_host *host, u32 relevant, unsigned int hc)
1590 {
1591         void __iomem *mmio = host->iomap[MV_PRIMARY_BAR];
1592         void __iomem *hc_mmio = mv_hc_base(mmio, hc);
1593         u32 hc_irq_cause;
1594         int port, port0;
1595
1596         if (hc == 0)
1597                 port0 = 0;
1598         else
1599                 port0 = MV_PORTS_PER_HC;
1600
1601         /* we'll need the HC success int register in most cases */
1602         hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
1603         if (!hc_irq_cause)
1604                 return;
1605
1606         writelfl(~hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
1607
1608         VPRINTK("ENTER, hc%u relevant=0x%08x HC IRQ cause=0x%08x\n",
1609                 hc, relevant, hc_irq_cause);
1610
1611         for (port = port0; port < port0 + MV_PORTS_PER_HC; port++) {
1612                 struct ata_port *ap = host->ports[port];
1613                 struct mv_port_priv *pp = ap->private_data;
1614                 int have_err_bits, hard_port, shift;
1615
1616                 if ((!ap) || (ap->flags & ATA_FLAG_DISABLED))
1617                         continue;
1618
1619                 shift = port << 1;              /* (port * 2) */
1620                 if (port >= MV_PORTS_PER_HC) {
1621                         shift++;        /* skip bit 8 in the HC Main IRQ reg */
1622                 }
1623                 have_err_bits = ((PORT0_ERR << shift) & relevant);
1624
1625                 if (unlikely(have_err_bits)) {
1626                         struct ata_queued_cmd *qc;
1627
1628                         qc = ata_qc_from_tag(ap, ap->link.active_tag);
1629                         if (qc && (qc->tf.flags & ATA_TFLAG_POLLING))
1630                                 continue;
1631
1632                         mv_err_intr(ap, qc);
1633                         continue;
1634                 }
1635
1636                 hard_port = mv_hardport_from_port(port); /* range 0..3 */
1637
1638                 if (pp->pp_flags & MV_PP_FLAG_EDMA_EN) {
1639                         if ((CRPB_DMA_DONE << hard_port) & hc_irq_cause)
1640                                 mv_intr_edma(ap);
1641                 } else {
1642                         if ((DEV_IRQ << hard_port) & hc_irq_cause)
1643                                 mv_intr_pio(ap);
1644                 }
1645         }
1646         VPRINTK("EXIT\n");
1647 }
1648
1649 static void mv_pci_error(struct ata_host *host, void __iomem *mmio)
1650 {
1651         struct ata_port *ap;
1652         struct ata_queued_cmd *qc;
1653         struct ata_eh_info *ehi;
1654         unsigned int i, err_mask, printed = 0;
1655         u32 err_cause;
1656
1657         err_cause = readl(mmio + PCI_IRQ_CAUSE_OFS);
1658
1659         dev_printk(KERN_ERR, host->dev, "PCI ERROR; PCI IRQ cause=0x%08x\n",
1660                    err_cause);
1661
1662         DPRINTK("All regs @ PCI error\n");
1663         mv_dump_all_regs(mmio, -1, to_pci_dev(host->dev));
1664
1665         writelfl(0, mmio + PCI_IRQ_CAUSE_OFS);
1666
1667         for (i = 0; i < host->n_ports; i++) {
1668                 ap = host->ports[i];
1669                 if (!ata_link_offline(&ap->link)) {
1670                         ehi = &ap->link.eh_info;
1671                         ata_ehi_clear_desc(ehi);
1672                         if (!printed++)
1673                                 ata_ehi_push_desc(ehi,
1674                                         "PCI err cause 0x%08x", err_cause);
1675                         err_mask = AC_ERR_HOST_BUS;
1676                         ehi->action = ATA_EH_HARDRESET;
1677                         qc = ata_qc_from_tag(ap, ap->link.active_tag);
1678                         if (qc)
1679                                 qc->err_mask |= err_mask;
1680                         else
1681                                 ehi->err_mask |= err_mask;
1682
1683                         ata_port_freeze(ap);
1684                 }
1685         }
1686 }
1687
1688 /**
1689  *      mv_interrupt - Main interrupt event handler
1690  *      @irq: unused
1691  *      @dev_instance: private data; in this case the host structure
1692  *
1693  *      Read the read only register to determine if any host
1694  *      controllers have pending interrupts.  If so, call lower level
1695  *      routine to handle.  Also check for PCI errors which are only
1696  *      reported here.
1697  *
1698  *      LOCKING:
1699  *      This routine holds the host lock while processing pending
1700  *      interrupts.
1701  */
1702 static irqreturn_t mv_interrupt(int irq, void *dev_instance)
1703 {
1704         struct ata_host *host = dev_instance;
1705         unsigned int hc, handled = 0, n_hcs;
1706         void __iomem *mmio = host->iomap[MV_PRIMARY_BAR];
1707         u32 irq_stat;
1708
1709         irq_stat = readl(mmio + HC_MAIN_IRQ_CAUSE_OFS);
1710
1711         /* check the cases where we either have nothing pending or have read
1712          * a bogus register value which can indicate HW removal or PCI fault
1713          */
1714         if (!irq_stat || (0xffffffffU == irq_stat))
1715                 return IRQ_NONE;
1716
1717         n_hcs = mv_get_hc_count(host->ports[0]->flags);
1718         spin_lock(&host->lock);
1719
1720         if (unlikely(irq_stat & PCI_ERR)) {
1721                 mv_pci_error(host, mmio);
1722                 handled = 1;
1723                 goto out_unlock;        /* skip all other HC irq handling */
1724         }
1725
1726         for (hc = 0; hc < n_hcs; hc++) {
1727                 u32 relevant = irq_stat & (HC0_IRQ_PEND << (hc * HC_SHIFT));
1728                 if (relevant) {
1729                         mv_host_intr(host, relevant, hc);
1730                         handled = 1;
1731                 }
1732         }
1733
1734 out_unlock:
1735         spin_unlock(&host->lock);
1736
1737         return IRQ_RETVAL(handled);
1738 }
1739
1740 static void __iomem *mv5_phy_base(void __iomem *mmio, unsigned int port)
1741 {
1742         void __iomem *hc_mmio = mv_hc_base_from_port(mmio, port);
1743         unsigned long ofs = (mv_hardport_from_port(port) + 1) * 0x100UL;
1744
1745         return hc_mmio + ofs;
1746 }
1747
1748 static unsigned int mv5_scr_offset(unsigned int sc_reg_in)
1749 {
1750         unsigned int ofs;
1751
1752         switch (sc_reg_in) {
1753         case SCR_STATUS:
1754         case SCR_ERROR:
1755         case SCR_CONTROL:
1756                 ofs = sc_reg_in * sizeof(u32);
1757                 break;
1758         default:
1759                 ofs = 0xffffffffU;
1760                 break;
1761         }
1762         return ofs;
1763 }
1764
1765 static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
1766 {
1767         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
1768         void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
1769         unsigned int ofs = mv5_scr_offset(sc_reg_in);
1770
1771         if (ofs != 0xffffffffU) {
1772                 *val = readl(addr + ofs);
1773                 return 0;
1774         } else
1775                 return -EINVAL;
1776 }
1777
1778 static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
1779 {
1780         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
1781         void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
1782         unsigned int ofs = mv5_scr_offset(sc_reg_in);
1783
1784         if (ofs != 0xffffffffU) {
1785                 writelfl(val, addr + ofs);
1786                 return 0;
1787         } else
1788                 return -EINVAL;
1789 }
1790
1791 static void mv5_reset_bus(struct pci_dev *pdev, void __iomem *mmio)
1792 {
1793         int early_5080;
1794
1795         early_5080 = (pdev->device == 0x5080) && (pdev->revision == 0);
1796
1797         if (!early_5080) {
1798                 u32 tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
1799                 tmp |= (1 << 0);
1800                 writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
1801         }
1802
1803         mv_reset_pci_bus(pdev, mmio);
1804 }
1805
1806 static void mv5_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
1807 {
1808         writel(0x0fcfffff, mmio + MV_FLASH_CTL);
1809 }
1810
1811 static void mv5_read_preamp(struct mv_host_priv *hpriv, int idx,
1812                            void __iomem *mmio)
1813 {
1814         void __iomem *phy_mmio = mv5_phy_base(mmio, idx);
1815         u32 tmp;
1816
1817         tmp = readl(phy_mmio + MV5_PHY_MODE);
1818
1819         hpriv->signal[idx].pre = tmp & 0x1800;  /* bits 12:11 */
1820         hpriv->signal[idx].amps = tmp & 0xe0;   /* bits 7:5 */
1821 }
1822
1823 static void mv5_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
1824 {
1825         u32 tmp;
1826
1827         writel(0, mmio + MV_GPIO_PORT_CTL);
1828
1829         /* FIXME: handle MV_HP_ERRATA_50XXB2 errata */
1830
1831         tmp = readl(mmio + MV_PCI_EXP_ROM_BAR_CTL);
1832         tmp |= ~(1 << 0);
1833         writel(tmp, mmio + MV_PCI_EXP_ROM_BAR_CTL);
1834 }
1835
1836 static void mv5_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
1837                            unsigned int port)
1838 {
1839         void __iomem *phy_mmio = mv5_phy_base(mmio, port);
1840         const u32 mask = (1<<12) | (1<<11) | (1<<7) | (1<<6) | (1<<5);
1841         u32 tmp;
1842         int fix_apm_sq = (hpriv->hp_flags & MV_HP_ERRATA_50XXB0);
1843
1844         if (fix_apm_sq) {
1845                 tmp = readl(phy_mmio + MV5_LT_MODE);
1846                 tmp |= (1 << 19);
1847                 writel(tmp, phy_mmio + MV5_LT_MODE);
1848
1849                 tmp = readl(phy_mmio + MV5_PHY_CTL);
1850                 tmp &= ~0x3;
1851                 tmp |= 0x1;
1852                 writel(tmp, phy_mmio + MV5_PHY_CTL);
1853         }
1854
1855         tmp = readl(phy_mmio + MV5_PHY_MODE);
1856         tmp &= ~mask;
1857         tmp |= hpriv->signal[port].pre;
1858         tmp |= hpriv->signal[port].amps;
1859         writel(tmp, phy_mmio + MV5_PHY_MODE);
1860 }
1861
1862
1863 #undef ZERO
1864 #define ZERO(reg) writel(0, port_mmio + (reg))
1865 static void mv5_reset_hc_port(struct mv_host_priv *hpriv, void __iomem *mmio,
1866                              unsigned int port)
1867 {
1868         void __iomem *port_mmio = mv_port_base(mmio, port);
1869
1870         writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
1871
1872         mv_channel_reset(hpriv, mmio, port);
1873
1874         ZERO(0x028);    /* command */
1875         writel(0x11f, port_mmio + EDMA_CFG_OFS);
1876         ZERO(0x004);    /* timer */
1877         ZERO(0x008);    /* irq err cause */
1878         ZERO(0x00c);    /* irq err mask */
1879         ZERO(0x010);    /* rq bah */
1880         ZERO(0x014);    /* rq inp */
1881         ZERO(0x018);    /* rq outp */
1882         ZERO(0x01c);    /* respq bah */
1883         ZERO(0x024);    /* respq outp */
1884         ZERO(0x020);    /* respq inp */
1885         ZERO(0x02c);    /* test control */
1886         writel(0xbc, port_mmio + EDMA_IORDY_TMOUT);
1887 }
1888 #undef ZERO
1889
1890 #define ZERO(reg) writel(0, hc_mmio + (reg))
1891 static void mv5_reset_one_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
1892                         unsigned int hc)
1893 {
1894         void __iomem *hc_mmio = mv_hc_base(mmio, hc);
1895         u32 tmp;
1896
1897         ZERO(0x00c);
1898         ZERO(0x010);
1899         ZERO(0x014);
1900         ZERO(0x018);
1901
1902         tmp = readl(hc_mmio + 0x20);
1903         tmp &= 0x1c1c1c1c;
1904         tmp |= 0x03030303;
1905         writel(tmp, hc_mmio + 0x20);
1906 }
1907 #undef ZERO
1908
1909 static int mv5_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
1910                         unsigned int n_hc)
1911 {
1912         unsigned int hc, port;
1913
1914         for (hc = 0; hc < n_hc; hc++) {
1915                 for (port = 0; port < MV_PORTS_PER_HC; port++)
1916                         mv5_reset_hc_port(hpriv, mmio,
1917                                           (hc * MV_PORTS_PER_HC) + port);
1918
1919                 mv5_reset_one_hc(hpriv, mmio, hc);
1920         }
1921
1922         return 0;
1923 }
1924
1925 #undef ZERO
1926 #define ZERO(reg) writel(0, mmio + (reg))
1927 static void mv_reset_pci_bus(struct pci_dev *pdev, void __iomem *mmio)
1928 {
1929         u32 tmp;
1930
1931         tmp = readl(mmio + MV_PCI_MODE);
1932         tmp &= 0xff00ffff;
1933         writel(tmp, mmio + MV_PCI_MODE);
1934
1935         ZERO(MV_PCI_DISC_TIMER);
1936         ZERO(MV_PCI_MSI_TRIGGER);
1937         writel(0x000100ff, mmio + MV_PCI_XBAR_TMOUT);
1938         ZERO(HC_MAIN_IRQ_MASK_OFS);
1939         ZERO(MV_PCI_SERR_MASK);
1940         ZERO(PCI_IRQ_CAUSE_OFS);
1941         ZERO(PCI_IRQ_MASK_OFS);
1942         ZERO(MV_PCI_ERR_LOW_ADDRESS);
1943         ZERO(MV_PCI_ERR_HIGH_ADDRESS);
1944         ZERO(MV_PCI_ERR_ATTRIBUTE);
1945         ZERO(MV_PCI_ERR_COMMAND);
1946 }
1947 #undef ZERO
1948
1949 static void mv6_reset_flash(struct mv_host_priv *hpriv, void __iomem *mmio)
1950 {
1951         u32 tmp;
1952
1953         mv5_reset_flash(hpriv, mmio);
1954
1955         tmp = readl(mmio + MV_GPIO_PORT_CTL);
1956         tmp &= 0x3;
1957         tmp |= (1 << 5) | (1 << 6);
1958         writel(tmp, mmio + MV_GPIO_PORT_CTL);
1959 }
1960
1961 /**
1962  *      mv6_reset_hc - Perform the 6xxx global soft reset
1963  *      @mmio: base address of the HBA
1964  *
1965  *      This routine only applies to 6xxx parts.
1966  *
1967  *      LOCKING:
1968  *      Inherited from caller.
1969  */
1970 static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
1971                         unsigned int n_hc)
1972 {
1973         void __iomem *reg = mmio + PCI_MAIN_CMD_STS_OFS;
1974         int i, rc = 0;
1975         u32 t;
1976
1977         /* Following procedure defined in PCI "main command and status
1978          * register" table.
1979          */
1980         t = readl(reg);
1981         writel(t | STOP_PCI_MASTER, reg);
1982
1983         for (i = 0; i < 1000; i++) {
1984                 udelay(1);
1985                 t = readl(reg);
1986                 if (PCI_MASTER_EMPTY & t)
1987                         break;
1988         }
1989         if (!(PCI_MASTER_EMPTY & t)) {
1990                 printk(KERN_ERR DRV_NAME ": PCI master won't flush\n");
1991                 rc = 1;
1992                 goto done;
1993         }
1994
1995         /* set reset */
1996         i = 5;
1997         do {
1998                 writel(t | GLOB_SFT_RST, reg);
1999                 t = readl(reg);
2000                 udelay(1);
2001         } while (!(GLOB_SFT_RST & t) && (i-- > 0));
2002
2003         if (!(GLOB_SFT_RST & t)) {
2004                 printk(KERN_ERR DRV_NAME ": can't set global reset\n");
2005                 rc = 1;
2006                 goto done;
2007         }
2008
2009         /* clear reset and *reenable the PCI master* (not mentioned in spec) */
2010         i = 5;
2011         do {
2012                 writel(t & ~(GLOB_SFT_RST | STOP_PCI_MASTER), reg);
2013                 t = readl(reg);
2014                 udelay(1);
2015         } while ((GLOB_SFT_RST & t) && (i-- > 0));
2016
2017         if (GLOB_SFT_RST & t) {
2018                 printk(KERN_ERR DRV_NAME ": can't clear global reset\n");
2019                 rc = 1;
2020         }
2021 done:
2022         return rc;
2023 }
2024
2025 static void mv6_read_preamp(struct mv_host_priv *hpriv, int idx,
2026                            void __iomem *mmio)
2027 {
2028         void __iomem *port_mmio;
2029         u32 tmp;
2030
2031         tmp = readl(mmio + MV_RESET_CFG);
2032         if ((tmp & (1 << 0)) == 0) {
2033                 hpriv->signal[idx].amps = 0x7 << 8;
2034                 hpriv->signal[idx].pre = 0x1 << 5;
2035                 return;
2036         }
2037
2038         port_mmio = mv_port_base(mmio, idx);
2039         tmp = readl(port_mmio + PHY_MODE2);
2040
2041         hpriv->signal[idx].amps = tmp & 0x700;  /* bits 10:8 */
2042         hpriv->signal[idx].pre = tmp & 0xe0;    /* bits 7:5 */
2043 }
2044
2045 static void mv6_enable_leds(struct mv_host_priv *hpriv, void __iomem *mmio)
2046 {
2047         writel(0x00000060, mmio + MV_GPIO_PORT_CTL);
2048 }
2049
2050 static void mv6_phy_errata(struct mv_host_priv *hpriv, void __iomem *mmio,
2051                            unsigned int port)
2052 {
2053         void __iomem *port_mmio = mv_port_base(mmio, port);
2054
2055         u32 hp_flags = hpriv->hp_flags;
2056         int fix_phy_mode2 =
2057                 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
2058         int fix_phy_mode4 =
2059                 hp_flags & (MV_HP_ERRATA_60X1B2 | MV_HP_ERRATA_60X1C0);
2060         u32 m2, tmp;
2061
2062         if (fix_phy_mode2) {
2063                 m2 = readl(port_mmio + PHY_MODE2);
2064                 m2 &= ~(1 << 16);
2065                 m2 |= (1 << 31);
2066                 writel(m2, port_mmio + PHY_MODE2);
2067
2068                 udelay(200);
2069
2070                 m2 = readl(port_mmio + PHY_MODE2);
2071                 m2 &= ~((1 << 16) | (1 << 31));
2072                 writel(m2, port_mmio + PHY_MODE2);
2073
2074                 udelay(200);
2075         }
2076
2077         /* who knows what this magic does */
2078         tmp = readl(port_mmio + PHY_MODE3);
2079         tmp &= ~0x7F800000;
2080         tmp |= 0x2A800000;
2081         writel(tmp, port_mmio + PHY_MODE3);
2082
2083         if (fix_phy_mode4) {
2084                 u32 m4;
2085
2086                 m4 = readl(port_mmio + PHY_MODE4);
2087
2088                 if (hp_flags & MV_HP_ERRATA_60X1B2)
2089                         tmp = readl(port_mmio + 0x310);
2090
2091                 m4 = (m4 & ~(1 << 1)) | (1 << 0);
2092
2093                 writel(m4, port_mmio + PHY_MODE4);
2094
2095                 if (hp_flags & MV_HP_ERRATA_60X1B2)
2096                         writel(tmp, port_mmio + 0x310);
2097         }
2098
2099         /* Revert values of pre-emphasis and signal amps to the saved ones */
2100         m2 = readl(port_mmio + PHY_MODE2);
2101
2102         m2 &= ~MV_M2_PREAMP_MASK;
2103         m2 |= hpriv->signal[port].amps;
2104         m2 |= hpriv->signal[port].pre;
2105         m2 &= ~(1 << 16);
2106
2107         /* according to mvSata 3.6.1, some IIE values are fixed */
2108         if (IS_GEN_IIE(hpriv)) {
2109                 m2 &= ~0xC30FF01F;
2110                 m2 |= 0x0000900F;
2111         }
2112
2113         writel(m2, port_mmio + PHY_MODE2);
2114 }
2115
2116 static void mv_channel_reset(struct mv_host_priv *hpriv, void __iomem *mmio,
2117                              unsigned int port_no)
2118 {
2119         void __iomem *port_mmio = mv_port_base(mmio, port_no);
2120
2121         writelfl(ATA_RST, port_mmio + EDMA_CMD_OFS);
2122
2123         if (IS_GEN_II(hpriv)) {
2124                 u32 ifctl = readl(port_mmio + SATA_INTERFACE_CTL);
2125                 ifctl |= (1 << 7);              /* enable gen2i speed */
2126                 ifctl = (ifctl & 0xfff) | 0x9b1000; /* from chip spec */
2127                 writelfl(ifctl, port_mmio + SATA_INTERFACE_CTL);
2128         }
2129
2130         udelay(25);             /* allow reset propagation */
2131
2132         /* Spec never mentions clearing the bit.  Marvell's driver does
2133          * clear the bit, however.
2134          */
2135         writelfl(0, port_mmio + EDMA_CMD_OFS);
2136
2137         hpriv->ops->phy_errata(hpriv, mmio, port_no);
2138
2139         if (IS_GEN_I(hpriv))
2140                 mdelay(1);
2141 }
2142
2143 /**
2144  *      mv_phy_reset - Perform eDMA reset followed by COMRESET
2145  *      @ap: ATA channel to manipulate
2146  *
2147  *      Part of this is taken from __sata_phy_reset and modified to
2148  *      not sleep since this routine gets called from interrupt level.
2149  *
2150  *      LOCKING:
2151  *      Inherited from caller.  This is coded to safe to call at
2152  *      interrupt level, i.e. it does not sleep.
2153  */
2154 static void mv_phy_reset(struct ata_port *ap, unsigned int *class,
2155                          unsigned long deadline)
2156 {
2157         struct mv_port_priv *pp = ap->private_data;
2158         struct mv_host_priv *hpriv = ap->host->private_data;
2159         void __iomem *port_mmio = mv_ap_base(ap);
2160         int retry = 5;
2161         u32 sstatus;
2162
2163         VPRINTK("ENTER, port %u, mmio 0x%p\n", ap->port_no, port_mmio);
2164
2165 #ifdef DEBUG
2166         {
2167                 u32 sstatus, serror, scontrol;
2168
2169                 mv_scr_read(ap, SCR_STATUS, &sstatus);
2170                 mv_scr_read(ap, SCR_ERROR, &serror);
2171                 mv_scr_read(ap, SCR_CONTROL, &scontrol);
2172                 DPRINTK("S-regs after ATA_RST: SStat 0x%08x SErr 0x%08x "
2173                         "SCtrl 0x%08x\n", status, serror, scontrol);
2174         }
2175 #endif
2176
2177         /* Issue COMRESET via SControl */
2178 comreset_retry:
2179         sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x301);
2180         msleep(1);
2181
2182         sata_scr_write_flush(&ap->link, SCR_CONTROL, 0x300);
2183         msleep(20);
2184
2185         do {
2186                 sata_scr_read(&ap->link, SCR_STATUS, &sstatus);
2187                 if (((sstatus & 0x3) == 3) || ((sstatus & 0x3) == 0))
2188                         break;
2189
2190                 msleep(1);
2191         } while (time_before(jiffies, deadline));
2192
2193         /* work around errata */
2194         if (IS_GEN_II(hpriv) &&
2195             (sstatus != 0x0) && (sstatus != 0x113) && (sstatus != 0x123) &&
2196             (retry-- > 0))
2197                 goto comreset_retry;
2198
2199 #ifdef DEBUG
2200         {
2201                 u32 sstatus, serror, scontrol;
2202
2203                 mv_scr_read(ap, SCR_STATUS, &sstatus);
2204                 mv_scr_read(ap, SCR_ERROR, &serror);
2205                 mv_scr_read(ap, SCR_CONTROL, &scontrol);
2206                 DPRINTK("S-regs after PHY wake: SStat 0x%08x SErr 0x%08x "
2207                         "SCtrl 0x%08x\n", sstatus, serror, scontrol);
2208         }
2209 #endif
2210
2211         if (ata_link_offline(&ap->link)) {
2212                 *class = ATA_DEV_NONE;
2213                 return;
2214         }
2215
2216         /* even after SStatus reflects that device is ready,
2217          * it seems to take a while for link to be fully
2218          * established (and thus Status no longer 0x80/0x7F),
2219          * so we poll a bit for that, here.
2220          */
2221         retry = 20;
2222         while (1) {
2223                 u8 drv_stat = ata_check_status(ap);
2224                 if ((drv_stat != 0x80) && (drv_stat != 0x7f))
2225                         break;
2226                 msleep(500);
2227                 if (retry-- <= 0)
2228                         break;
2229                 if (time_after(jiffies, deadline))
2230                         break;
2231         }
2232
2233         /* FIXME: if we passed the deadline, the following
2234          * code probably produces an invalid result
2235          */
2236
2237         /* finally, read device signature from TF registers */
2238         *class = ata_dev_try_classify(ap->link.device, 1, NULL);
2239
2240         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2241
2242         WARN_ON(pp->pp_flags & MV_PP_FLAG_EDMA_EN);
2243
2244         VPRINTK("EXIT\n");
2245 }
2246
2247 static int mv_prereset(struct ata_link *link, unsigned long deadline)
2248 {
2249         struct ata_port *ap = link->ap;
2250         struct mv_port_priv *pp = ap->private_data;
2251         struct ata_eh_context *ehc = &link->eh_context;
2252         int rc;
2253
2254         rc = mv_stop_dma(ap);
2255         if (rc)
2256                 ehc->i.action |= ATA_EH_HARDRESET;
2257
2258         if (!(pp->pp_flags & MV_PP_FLAG_HAD_A_RESET)) {
2259                 pp->pp_flags |= MV_PP_FLAG_HAD_A_RESET;
2260                 ehc->i.action |= ATA_EH_HARDRESET;
2261         }
2262
2263         /* if we're about to do hardreset, nothing more to do */
2264         if (ehc->i.action & ATA_EH_HARDRESET)
2265                 return 0;
2266
2267         if (ata_link_online(link))
2268                 rc = ata_wait_ready(ap, deadline);
2269         else
2270                 rc = -ENODEV;
2271
2272         return rc;
2273 }
2274
2275 static int mv_hardreset(struct ata_link *link, unsigned int *class,
2276                         unsigned long deadline)
2277 {
2278         struct ata_port *ap = link->ap;
2279         struct mv_host_priv *hpriv = ap->host->private_data;
2280         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
2281
2282         mv_stop_dma(ap);
2283
2284         mv_channel_reset(hpriv, mmio, ap->port_no);
2285
2286         mv_phy_reset(ap, class, deadline);
2287
2288         return 0;
2289 }
2290
2291 static void mv_postreset(struct ata_link *link, unsigned int *classes)
2292 {
2293         struct ata_port *ap = link->ap;
2294         u32 serr;
2295
2296         /* print link status */
2297         sata_print_link_status(link);
2298
2299         /* clear SError */
2300         sata_scr_read(link, SCR_ERROR, &serr);
2301         sata_scr_write_flush(link, SCR_ERROR, serr);
2302
2303         /* bail out if no device is present */
2304         if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2305                 DPRINTK("EXIT, no device\n");
2306                 return;
2307         }
2308
2309         /* set up device control */
2310         iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
2311 }
2312
2313 static void mv_error_handler(struct ata_port *ap)
2314 {
2315         ata_do_eh(ap, mv_prereset, ata_std_softreset,
2316                   mv_hardreset, mv_postreset);
2317 }
2318
2319 static void mv_post_int_cmd(struct ata_queued_cmd *qc)
2320 {
2321         mv_stop_dma(qc->ap);
2322 }
2323
2324 static void mv_eh_freeze(struct ata_port *ap)
2325 {
2326         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
2327         unsigned int hc = (ap->port_no > 3) ? 1 : 0;
2328         u32 tmp, mask;
2329         unsigned int shift;
2330
2331         /* FIXME: handle coalescing completion events properly */
2332
2333         shift = ap->port_no * 2;
2334         if (hc > 0)
2335                 shift++;
2336
2337         mask = 0x3 << shift;
2338
2339         /* disable assertion of portN err, done events */
2340         tmp = readl(mmio + HC_MAIN_IRQ_MASK_OFS);
2341         writelfl(tmp & ~mask, mmio + HC_MAIN_IRQ_MASK_OFS);
2342 }
2343
2344 static void mv_eh_thaw(struct ata_port *ap)
2345 {
2346         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
2347         unsigned int hc = (ap->port_no > 3) ? 1 : 0;
2348         void __iomem *hc_mmio = mv_hc_base(mmio, hc);
2349         void __iomem *port_mmio = mv_ap_base(ap);
2350         u32 tmp, mask, hc_irq_cause;
2351         unsigned int shift, hc_port_no = ap->port_no;
2352
2353         /* FIXME: handle coalescing completion events properly */
2354
2355         shift = ap->port_no * 2;
2356         if (hc > 0) {
2357                 shift++;
2358                 hc_port_no -= 4;
2359         }
2360
2361         mask = 0x3 << shift;
2362
2363         /* clear EDMA errors on this port */
2364         writel(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2365
2366         /* clear pending irq events */
2367         hc_irq_cause = readl(hc_mmio + HC_IRQ_CAUSE_OFS);
2368         hc_irq_cause &= ~(1 << hc_port_no);     /* clear CRPB-done */
2369         hc_irq_cause &= ~(1 << (hc_port_no + 8)); /* clear Device int */
2370         writel(hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
2371
2372         /* enable assertion of portN err, done events */
2373         tmp = readl(mmio + HC_MAIN_IRQ_MASK_OFS);
2374         writelfl(tmp | mask, mmio + HC_MAIN_IRQ_MASK_OFS);
2375 }
2376
2377 /**
2378  *      mv_port_init - Perform some early initialization on a single port.
2379  *      @port: libata data structure storing shadow register addresses
2380  *      @port_mmio: base address of the port
2381  *
2382  *      Initialize shadow register mmio addresses, clear outstanding
2383  *      interrupts on the port, and unmask interrupts for the future
2384  *      start of the port.
2385  *
2386  *      LOCKING:
2387  *      Inherited from caller.
2388  */
2389 static void mv_port_init(struct ata_ioports *port,  void __iomem *port_mmio)
2390 {
2391         void __iomem *shd_base = port_mmio + SHD_BLK_OFS;
2392         unsigned serr_ofs;
2393
2394         /* PIO related setup
2395          */
2396         port->data_addr = shd_base + (sizeof(u32) * ATA_REG_DATA);
2397         port->error_addr =
2398                 port->feature_addr = shd_base + (sizeof(u32) * ATA_REG_ERR);
2399         port->nsect_addr = shd_base + (sizeof(u32) * ATA_REG_NSECT);
2400         port->lbal_addr = shd_base + (sizeof(u32) * ATA_REG_LBAL);
2401         port->lbam_addr = shd_base + (sizeof(u32) * ATA_REG_LBAM);
2402         port->lbah_addr = shd_base + (sizeof(u32) * ATA_REG_LBAH);
2403         port->device_addr = shd_base + (sizeof(u32) * ATA_REG_DEVICE);
2404         port->status_addr =
2405                 port->command_addr = shd_base + (sizeof(u32) * ATA_REG_STATUS);
2406         /* special case: control/altstatus doesn't have ATA_REG_ address */
2407         port->altstatus_addr = port->ctl_addr = shd_base + SHD_CTL_AST_OFS;
2408
2409         /* unused: */
2410         port->cmd_addr = port->bmdma_addr = port->scr_addr = NULL;
2411
2412         /* Clear any currently outstanding port interrupt conditions */
2413         serr_ofs = mv_scr_offset(SCR_ERROR);
2414         writelfl(readl(port_mmio + serr_ofs), port_mmio + serr_ofs);
2415         writelfl(0, port_mmio + EDMA_ERR_IRQ_CAUSE_OFS);
2416
2417         /* unmask all EDMA error interrupts */
2418         writelfl(~0, port_mmio + EDMA_ERR_IRQ_MASK_OFS);
2419
2420         VPRINTK("EDMA cfg=0x%08x EDMA IRQ err cause/mask=0x%08x/0x%08x\n",
2421                 readl(port_mmio + EDMA_CFG_OFS),
2422                 readl(port_mmio + EDMA_ERR_IRQ_CAUSE_OFS),
2423                 readl(port_mmio + EDMA_ERR_IRQ_MASK_OFS));
2424 }
2425
2426 static int mv_chip_id(struct ata_host *host, unsigned int board_idx)
2427 {
2428         struct pci_dev *pdev = to_pci_dev(host->dev);
2429         struct mv_host_priv *hpriv = host->private_data;
2430         u32 hp_flags = hpriv->hp_flags;
2431
2432         switch (board_idx) {
2433         case chip_5080:
2434                 hpriv->ops = &mv5xxx_ops;
2435                 hp_flags |= MV_HP_GEN_I;
2436
2437                 switch (pdev->revision) {
2438                 case 0x1:
2439                         hp_flags |= MV_HP_ERRATA_50XXB0;
2440                         break;
2441                 case 0x3:
2442                         hp_flags |= MV_HP_ERRATA_50XXB2;
2443                         break;
2444                 default:
2445                         dev_printk(KERN_WARNING, &pdev->dev,
2446                            "Applying 50XXB2 workarounds to unknown rev\n");
2447                         hp_flags |= MV_HP_ERRATA_50XXB2;
2448                         break;
2449                 }
2450                 break;
2451
2452         case chip_504x:
2453         case chip_508x:
2454                 hpriv->ops = &mv5xxx_ops;
2455                 hp_flags |= MV_HP_GEN_I;
2456
2457                 switch (pdev->revision) {
2458                 case 0x0:
2459                         hp_flags |= MV_HP_ERRATA_50XXB0;
2460                         break;
2461                 case 0x3:
2462                         hp_flags |= MV_HP_ERRATA_50XXB2;
2463                         break;
2464                 default:
2465                         dev_printk(KERN_WARNING, &pdev->dev,
2466                            "Applying B2 workarounds to unknown rev\n");
2467                         hp_flags |= MV_HP_ERRATA_50XXB2;
2468                         break;
2469                 }
2470                 break;
2471
2472         case chip_604x:
2473         case chip_608x:
2474                 hpriv->ops = &mv6xxx_ops;
2475                 hp_flags |= MV_HP_GEN_II;
2476
2477                 switch (pdev->revision) {
2478                 case 0x7:
2479                         hp_flags |= MV_HP_ERRATA_60X1B2;
2480                         break;
2481                 case 0x9:
2482                         hp_flags |= MV_HP_ERRATA_60X1C0;
2483                         break;
2484                 default:
2485                         dev_printk(KERN_WARNING, &pdev->dev,
2486                                    "Applying B2 workarounds to unknown rev\n");
2487                         hp_flags |= MV_HP_ERRATA_60X1B2;
2488                         break;
2489                 }
2490                 break;
2491
2492         case chip_7042:
2493         case chip_6042:
2494                 hpriv->ops = &mv6xxx_ops;
2495                 hp_flags |= MV_HP_GEN_IIE;
2496
2497                 switch (pdev->revision) {
2498                 case 0x0:
2499                         hp_flags |= MV_HP_ERRATA_XX42A0;
2500                         break;
2501                 case 0x1:
2502                         hp_flags |= MV_HP_ERRATA_60X1C0;
2503                         break;
2504                 default:
2505                         dev_printk(KERN_WARNING, &pdev->dev,
2506                            "Applying 60X1C0 workarounds to unknown rev\n");
2507                         hp_flags |= MV_HP_ERRATA_60X1C0;
2508                         break;
2509                 }
2510                 break;
2511
2512         default:
2513                 dev_printk(KERN_ERR, &pdev->dev,
2514                            "BUG: invalid board index %u\n", board_idx);
2515                 return 1;
2516         }
2517
2518         hpriv->hp_flags = hp_flags;
2519
2520         return 0;
2521 }
2522
2523 /**
2524  *      mv_init_host - Perform some early initialization of the host.
2525  *      @host: ATA host to initialize
2526  *      @board_idx: controller index
2527  *
2528  *      If possible, do an early global reset of the host.  Then do
2529  *      our port init and clear/unmask all/relevant host interrupts.
2530  *
2531  *      LOCKING:
2532  *      Inherited from caller.
2533  */
2534 static int mv_init_host(struct ata_host *host, unsigned int board_idx)
2535 {
2536         int rc = 0, n_hc, port, hc;
2537         struct pci_dev *pdev = to_pci_dev(host->dev);
2538         void __iomem *mmio = host->iomap[MV_PRIMARY_BAR];
2539         struct mv_host_priv *hpriv = host->private_data;
2540
2541         /* global interrupt mask */
2542         writel(0, mmio + HC_MAIN_IRQ_MASK_OFS);
2543
2544         rc = mv_chip_id(host, board_idx);
2545         if (rc)
2546                 goto done;
2547
2548         n_hc = mv_get_hc_count(host->ports[0]->flags);
2549
2550         for (port = 0; port < host->n_ports; port++)
2551                 hpriv->ops->read_preamp(hpriv, port, mmio);
2552
2553         rc = hpriv->ops->reset_hc(hpriv, mmio, n_hc);
2554         if (rc)
2555                 goto done;
2556
2557         hpriv->ops->reset_flash(hpriv, mmio);
2558         hpriv->ops->reset_bus(pdev, mmio);
2559         hpriv->ops->enable_leds(hpriv, mmio);
2560
2561         for (port = 0; port < host->n_ports; port++) {
2562                 if (IS_GEN_II(hpriv)) {
2563                         void __iomem *port_mmio = mv_port_base(mmio, port);
2564
2565                         u32 ifctl = readl(port_mmio + SATA_INTERFACE_CTL);
2566                         ifctl |= (1 << 7);              /* enable gen2i speed */
2567                         ifctl = (ifctl & 0xfff) | 0x9b1000; /* from chip spec */
2568                         writelfl(ifctl, port_mmio + SATA_INTERFACE_CTL);
2569                 }
2570
2571                 hpriv->ops->phy_errata(hpriv, mmio, port);
2572         }
2573
2574         for (port = 0; port < host->n_ports; port++) {
2575                 struct ata_port *ap = host->ports[port];
2576                 void __iomem *port_mmio = mv_port_base(mmio, port);
2577                 unsigned int offset = port_mmio - mmio;
2578
2579                 mv_port_init(&ap->ioaddr, port_mmio);
2580
2581                 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, -1, "mmio");
2582                 ata_port_pbar_desc(ap, MV_PRIMARY_BAR, offset, "port");
2583         }
2584
2585         for (hc = 0; hc < n_hc; hc++) {
2586                 void __iomem *hc_mmio = mv_hc_base(mmio, hc);
2587
2588                 VPRINTK("HC%i: HC config=0x%08x HC IRQ cause "
2589                         "(before clear)=0x%08x\n", hc,
2590                         readl(hc_mmio + HC_CFG_OFS),
2591                         readl(hc_mmio + HC_IRQ_CAUSE_OFS));
2592
2593                 /* Clear any currently outstanding hc interrupt conditions */
2594                 writelfl(0, hc_mmio + HC_IRQ_CAUSE_OFS);
2595         }
2596
2597         /* Clear any currently outstanding host interrupt conditions */
2598         writelfl(0, mmio + PCI_IRQ_CAUSE_OFS);
2599
2600         /* and unmask interrupt generation for host regs */
2601         writelfl(PCI_UNMASK_ALL_IRQS, mmio + PCI_IRQ_MASK_OFS);
2602
2603         if (IS_GEN_I(hpriv))
2604                 writelfl(~HC_MAIN_MASKED_IRQS_5, mmio + HC_MAIN_IRQ_MASK_OFS);
2605         else
2606                 writelfl(~HC_MAIN_MASKED_IRQS, mmio + HC_MAIN_IRQ_MASK_OFS);
2607
2608         VPRINTK("HC MAIN IRQ cause/mask=0x%08x/0x%08x "
2609                 "PCI int cause/mask=0x%08x/0x%08x\n",
2610                 readl(mmio + HC_MAIN_IRQ_CAUSE_OFS),
2611                 readl(mmio + HC_MAIN_IRQ_MASK_OFS),
2612                 readl(mmio + PCI_IRQ_CAUSE_OFS),
2613                 readl(mmio + PCI_IRQ_MASK_OFS));
2614
2615 done:
2616         return rc;
2617 }
2618
2619 /**
2620  *      mv_print_info - Dump key info to kernel log for perusal.
2621  *      @host: ATA host to print info about
2622  *
2623  *      FIXME: complete this.
2624  *
2625  *      LOCKING:
2626  *      Inherited from caller.
2627  */
2628 static void mv_print_info(struct ata_host *host)
2629 {
2630         struct pci_dev *pdev = to_pci_dev(host->dev);
2631         struct mv_host_priv *hpriv = host->private_data;
2632         u8 scc;
2633         const char *scc_s, *gen;
2634
2635         /* Use this to determine the HW stepping of the chip so we know
2636          * what errata to workaround
2637          */
2638         pci_read_config_byte(pdev, PCI_CLASS_DEVICE, &scc);
2639         if (scc == 0)
2640                 scc_s = "SCSI";
2641         else if (scc == 0x01)
2642                 scc_s = "RAID";
2643         else
2644                 scc_s = "?";
2645
2646         if (IS_GEN_I(hpriv))
2647                 gen = "I";
2648         else if (IS_GEN_II(hpriv))
2649                 gen = "II";
2650         else if (IS_GEN_IIE(hpriv))
2651                 gen = "IIE";
2652         else
2653                 gen = "?";
2654
2655         dev_printk(KERN_INFO, &pdev->dev,
2656                "Gen-%s %u slots %u ports %s mode IRQ via %s\n",
2657                gen, (unsigned)MV_MAX_Q_DEPTH, host->n_ports,
2658                scc_s, (MV_HP_FLAG_MSI & hpriv->hp_flags) ? "MSI" : "INTx");
2659 }
2660
2661 /**
2662  *      mv_init_one - handle a positive probe of a Marvell host
2663  *      @pdev: PCI device found
2664  *      @ent: PCI device ID entry for the matched host
2665  *
2666  *      LOCKING:
2667  *      Inherited from caller.
2668  */
2669 static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2670 {
2671         static int printed_version;
2672         unsigned int board_idx = (unsigned int)ent->driver_data;
2673         const struct ata_port_info *ppi[] = { &mv_port_info[board_idx], NULL };
2674         struct ata_host *host;
2675         struct mv_host_priv *hpriv;
2676         int n_ports, rc;
2677
2678         if (!printed_version++)
2679                 dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
2680
2681         /* allocate host */
2682         n_ports = mv_get_hc_count(ppi[0]->flags) * MV_PORTS_PER_HC;
2683
2684         host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
2685         hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
2686         if (!host || !hpriv)
2687                 return -ENOMEM;
2688         host->private_data = hpriv;
2689
2690         /* acquire resources */
2691         rc = pcim_enable_device(pdev);
2692         if (rc)
2693                 return rc;
2694
2695         rc = pcim_iomap_regions(pdev, 1 << MV_PRIMARY_BAR, DRV_NAME);
2696         if (rc == -EBUSY)
2697                 pcim_pin_device(pdev);
2698         if (rc)
2699                 return rc;
2700         host->iomap = pcim_iomap_table(pdev);
2701
2702         rc = pci_go_64(pdev);
2703         if (rc)
2704                 return rc;
2705
2706         /* initialize adapter */
2707         rc = mv_init_host(host, board_idx);
2708         if (rc)
2709                 return rc;
2710
2711         /* Enable interrupts */
2712         if (msi && pci_enable_msi(pdev))
2713                 pci_intx(pdev, 1);
2714
2715         mv_dump_pci_cfg(pdev, 0x68);
2716         mv_print_info(host);
2717
2718         pci_set_master(pdev);
2719         pci_try_set_mwi(pdev);
2720         return ata_host_activate(host, pdev->irq, mv_interrupt, IRQF_SHARED,
2721                                  IS_GEN_I(hpriv) ? &mv5_sht : &mv6_sht);
2722 }
2723
2724 static int __init mv_init(void)
2725 {
2726         return pci_register_driver(&mv_pci_driver);
2727 }
2728
2729 static void __exit mv_exit(void)
2730 {
2731         pci_unregister_driver(&mv_pci_driver);
2732 }
2733
2734 MODULE_AUTHOR("Brett Russ");
2735 MODULE_DESCRIPTION("SCSI low-level driver for Marvell SATA controllers");
2736 MODULE_LICENSE("GPL");
2737 MODULE_DEVICE_TABLE(pci, mv_pci_tbl);
2738 MODULE_VERSION(DRV_VERSION);
2739
2740 module_param(msi, int, 0444);
2741 MODULE_PARM_DESC(msi, "Enable use of PCI MSI (0=off, 1=on)");
2742
2743 module_init(mv_init);
2744 module_exit(mv_exit);