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