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