1 /* 2 * ahci.c - AHCI SATA support 3 * 4 * Maintained by: Jeff Garzik <jgarzik@pobox.com> 5 * Please ALWAYS copy linux-ide@vger.kernel.org 6 * on emails. 7 * 8 * Copyright 2004-2005 Red Hat, Inc. 9 * 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2, or (at your option) 14 * any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; see the file COPYING. If not, write to 23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 24 * 25 * 26 * libata documentation is available via 'make {ps|pdf}docs', 27 * as Documentation/DocBook/libata.* 28 * 29 * AHCI hardware documentation: 30 * http://www.intel.com/technology/serialata/pdf/rev1_0.pdf 31 * http://www.intel.com/technology/serialata/pdf/rev1_1.pdf 32 * 33 */ 34 35 #include <linux/kernel.h> 36 #include <linux/module.h> 37 #include <linux/pci.h> 38 #include <linux/init.h> 39 #include <linux/blkdev.h> 40 #include <linux/delay.h> 41 #include <linux/interrupt.h> 42 #include <linux/dma-mapping.h> 43 #include <linux/device.h> 44 #include <linux/dmi.h> 45 #include <scsi/scsi_host.h> 46 #include <scsi/scsi_cmnd.h> 47 #include <linux/libata.h> 48 49 #define DRV_NAME "ahci" 50 #define DRV_VERSION "3.0" 51 52 /* Enclosure Management Control */ 53 #define EM_CTRL_MSG_TYPE 0x000f0000 54 55 /* Enclosure Management LED Message Type */ 56 #define EM_MSG_LED_HBA_PORT 0x0000000f 57 #define EM_MSG_LED_PMP_SLOT 0x0000ff00 58 #define EM_MSG_LED_VALUE 0xffff0000 59 #define EM_MSG_LED_VALUE_ACTIVITY 0x00070000 60 #define EM_MSG_LED_VALUE_OFF 0xfff80000 61 #define EM_MSG_LED_VALUE_ON 0x00010000 62 63 static int ahci_skip_host_reset; 64 static int ahci_ignore_sss; 65 66 module_param_named(skip_host_reset, ahci_skip_host_reset, int, 0444); 67 MODULE_PARM_DESC(skip_host_reset, "skip global host reset (0=don't skip, 1=skip)"); 68 69 module_param_named(ignore_sss, ahci_ignore_sss, int, 0444); 70 MODULE_PARM_DESC(ignore_sss, "Ignore staggered spinup flag (0=don't ignore, 1=ignore)"); 71 72 static int ahci_enable_alpm(struct ata_port *ap, 73 enum link_pm policy); 74 static void ahci_disable_alpm(struct ata_port *ap); 75 static ssize_t ahci_led_show(struct ata_port *ap, char *buf); 76 static ssize_t ahci_led_store(struct ata_port *ap, const char *buf, 77 size_t size); 78 static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state, 79 ssize_t size); 80 81 enum { 82 AHCI_PCI_BAR = 5, 83 AHCI_MAX_PORTS = 32, 84 AHCI_MAX_SG = 168, /* hardware max is 64K */ 85 AHCI_DMA_BOUNDARY = 0xffffffff, 86 AHCI_MAX_CMDS = 32, 87 AHCI_CMD_SZ = 32, 88 AHCI_CMD_SLOT_SZ = AHCI_MAX_CMDS * AHCI_CMD_SZ, 89 AHCI_RX_FIS_SZ = 256, 90 AHCI_CMD_TBL_CDB = 0x40, 91 AHCI_CMD_TBL_HDR_SZ = 0x80, 92 AHCI_CMD_TBL_SZ = AHCI_CMD_TBL_HDR_SZ + (AHCI_MAX_SG * 16), 93 AHCI_CMD_TBL_AR_SZ = AHCI_CMD_TBL_SZ * AHCI_MAX_CMDS, 94 AHCI_PORT_PRIV_DMA_SZ = AHCI_CMD_SLOT_SZ + AHCI_CMD_TBL_AR_SZ + 95 AHCI_RX_FIS_SZ, 96 AHCI_IRQ_ON_SG = (1 << 31), 97 AHCI_CMD_ATAPI = (1 << 5), 98 AHCI_CMD_WRITE = (1 << 6), 99 AHCI_CMD_PREFETCH = (1 << 7), 100 AHCI_CMD_RESET = (1 << 8), 101 AHCI_CMD_CLR_BUSY = (1 << 10), 102 103 RX_FIS_D2H_REG = 0x40, /* offset of D2H Register FIS data */ 104 RX_FIS_SDB = 0x58, /* offset of SDB FIS data */ 105 RX_FIS_UNK = 0x60, /* offset of Unknown FIS data */ 106 107 board_ahci = 0, 108 board_ahci_vt8251 = 1, 109 board_ahci_ign_iferr = 2, 110 board_ahci_sb600 = 3, 111 board_ahci_mv = 4, 112 board_ahci_sb700 = 5, /* for SB700 and SB800 */ 113 board_ahci_mcp65 = 6, 114 board_ahci_nopmp = 7, 115 board_ahci_yesncq = 8, 116 117 /* global controller registers */ 118 HOST_CAP = 0x00, /* host capabilities */ 119 HOST_CTL = 0x04, /* global host control */ 120 HOST_IRQ_STAT = 0x08, /* interrupt status */ 121 HOST_PORTS_IMPL = 0x0c, /* bitmap of implemented ports */ 122 HOST_VERSION = 0x10, /* AHCI spec. version compliancy */ 123 HOST_EM_LOC = 0x1c, /* Enclosure Management location */ 124 HOST_EM_CTL = 0x20, /* Enclosure Management Control */ 125 126 /* HOST_CTL bits */ 127 HOST_RESET = (1 << 0), /* reset controller; self-clear */ 128 HOST_IRQ_EN = (1 << 1), /* global IRQ enable */ 129 HOST_AHCI_EN = (1 << 31), /* AHCI enabled */ 130 131 /* HOST_CAP bits */ 132 HOST_CAP_EMS = (1 << 6), /* Enclosure Management support */ 133 HOST_CAP_SSC = (1 << 14), /* Slumber capable */ 134 HOST_CAP_PMP = (1 << 17), /* Port Multiplier support */ 135 HOST_CAP_CLO = (1 << 24), /* Command List Override support */ 136 HOST_CAP_ALPM = (1 << 26), /* Aggressive Link PM support */ 137 HOST_CAP_SSS = (1 << 27), /* Staggered Spin-up */ 138 HOST_CAP_SNTF = (1 << 29), /* SNotification register */ 139 HOST_CAP_NCQ = (1 << 30), /* Native Command Queueing */ 140 HOST_CAP_64 = (1 << 31), /* PCI DAC (64-bit DMA) support */ 141 142 /* registers for each SATA port */ 143 PORT_LST_ADDR = 0x00, /* command list DMA addr */ 144 PORT_LST_ADDR_HI = 0x04, /* command list DMA addr hi */ 145 PORT_FIS_ADDR = 0x08, /* FIS rx buf addr */ 146 PORT_FIS_ADDR_HI = 0x0c, /* FIS rx buf addr hi */ 147 PORT_IRQ_STAT = 0x10, /* interrupt status */ 148 PORT_IRQ_MASK = 0x14, /* interrupt enable/disable mask */ 149 PORT_CMD = 0x18, /* port command */ 150 PORT_TFDATA = 0x20, /* taskfile data */ 151 PORT_SIG = 0x24, /* device TF signature */ 152 PORT_CMD_ISSUE = 0x38, /* command issue */ 153 PORT_SCR_STAT = 0x28, /* SATA phy register: SStatus */ 154 PORT_SCR_CTL = 0x2c, /* SATA phy register: SControl */ 155 PORT_SCR_ERR = 0x30, /* SATA phy register: SError */ 156 PORT_SCR_ACT = 0x34, /* SATA phy register: SActive */ 157 PORT_SCR_NTF = 0x3c, /* SATA phy register: SNotification */ 158 159 /* PORT_IRQ_{STAT,MASK} bits */ 160 PORT_IRQ_COLD_PRES = (1 << 31), /* cold presence detect */ 161 PORT_IRQ_TF_ERR = (1 << 30), /* task file error */ 162 PORT_IRQ_HBUS_ERR = (1 << 29), /* host bus fatal error */ 163 PORT_IRQ_HBUS_DATA_ERR = (1 << 28), /* host bus data error */ 164 PORT_IRQ_IF_ERR = (1 << 27), /* interface fatal error */ 165 PORT_IRQ_IF_NONFATAL = (1 << 26), /* interface non-fatal error */ 166 PORT_IRQ_OVERFLOW = (1 << 24), /* xfer exhausted available S/G */ 167 PORT_IRQ_BAD_PMP = (1 << 23), /* incorrect port multiplier */ 168 169 PORT_IRQ_PHYRDY = (1 << 22), /* PhyRdy changed */ 170 PORT_IRQ_DEV_ILCK = (1 << 7), /* device interlock */ 171 PORT_IRQ_CONNECT = (1 << 6), /* port connect change status */ 172 PORT_IRQ_SG_DONE = (1 << 5), /* descriptor processed */ 173 PORT_IRQ_UNK_FIS = (1 << 4), /* unknown FIS rx'd */ 174 PORT_IRQ_SDB_FIS = (1 << 3), /* Set Device Bits FIS rx'd */ 175 PORT_IRQ_DMAS_FIS = (1 << 2), /* DMA Setup FIS rx'd */ 176 PORT_IRQ_PIOS_FIS = (1 << 1), /* PIO Setup FIS rx'd */ 177 PORT_IRQ_D2H_REG_FIS = (1 << 0), /* D2H Register FIS rx'd */ 178 179 PORT_IRQ_FREEZE = PORT_IRQ_HBUS_ERR | 180 PORT_IRQ_IF_ERR | 181 PORT_IRQ_CONNECT | 182 PORT_IRQ_PHYRDY | 183 PORT_IRQ_UNK_FIS | 184 PORT_IRQ_BAD_PMP, 185 PORT_IRQ_ERROR = PORT_IRQ_FREEZE | 186 PORT_IRQ_TF_ERR | 187 PORT_IRQ_HBUS_DATA_ERR, 188 DEF_PORT_IRQ = PORT_IRQ_ERROR | PORT_IRQ_SG_DONE | 189 PORT_IRQ_SDB_FIS | PORT_IRQ_DMAS_FIS | 190 PORT_IRQ_PIOS_FIS | PORT_IRQ_D2H_REG_FIS, 191 192 /* PORT_CMD bits */ 193 PORT_CMD_ASP = (1 << 27), /* Aggressive Slumber/Partial */ 194 PORT_CMD_ALPE = (1 << 26), /* Aggressive Link PM enable */ 195 PORT_CMD_ATAPI = (1 << 24), /* Device is ATAPI */ 196 PORT_CMD_PMP = (1 << 17), /* PMP attached */ 197 PORT_CMD_LIST_ON = (1 << 15), /* cmd list DMA engine running */ 198 PORT_CMD_FIS_ON = (1 << 14), /* FIS DMA engine running */ 199 PORT_CMD_FIS_RX = (1 << 4), /* Enable FIS receive DMA engine */ 200 PORT_CMD_CLO = (1 << 3), /* Command list override */ 201 PORT_CMD_POWER_ON = (1 << 2), /* Power up device */ 202 PORT_CMD_SPIN_UP = (1 << 1), /* Spin up device */ 203 PORT_CMD_START = (1 << 0), /* Enable port DMA engine */ 204 205 PORT_CMD_ICC_MASK = (0xf << 28), /* i/f ICC state mask */ 206 PORT_CMD_ICC_ACTIVE = (0x1 << 28), /* Put i/f in active state */ 207 PORT_CMD_ICC_PARTIAL = (0x2 << 28), /* Put i/f in partial state */ 208 PORT_CMD_ICC_SLUMBER = (0x6 << 28), /* Put i/f in slumber state */ 209 210 /* hpriv->flags bits */ 211 AHCI_HFLAG_NO_NCQ = (1 << 0), 212 AHCI_HFLAG_IGN_IRQ_IF_ERR = (1 << 1), /* ignore IRQ_IF_ERR */ 213 AHCI_HFLAG_IGN_SERR_INTERNAL = (1 << 2), /* ignore SERR_INTERNAL */ 214 AHCI_HFLAG_32BIT_ONLY = (1 << 3), /* force 32bit */ 215 AHCI_HFLAG_MV_PATA = (1 << 4), /* PATA port */ 216 AHCI_HFLAG_NO_MSI = (1 << 5), /* no PCI MSI */ 217 AHCI_HFLAG_NO_PMP = (1 << 6), /* no PMP */ 218 AHCI_HFLAG_NO_HOTPLUG = (1 << 7), /* ignore PxSERR.DIAG.N */ 219 AHCI_HFLAG_SECT255 = (1 << 8), /* max 255 sectors */ 220 AHCI_HFLAG_YES_NCQ = (1 << 9), /* force NCQ cap on */ 221 AHCI_HFLAG_NO_SUSPEND = (1 << 10), /* don't suspend */ 222 AHCI_HFLAG_SRST_TOUT_IS_OFFLINE = (1 << 11), /* treat SRST timeout as 223 link offline */ 224 225 /* ap->flags bits */ 226 227 AHCI_FLAG_COMMON = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY | 228 ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA | 229 ATA_FLAG_ACPI_SATA | ATA_FLAG_AN | 230 ATA_FLAG_IPM, 231 232 ICH_MAP = 0x90, /* ICH MAP register */ 233 234 /* em constants */ 235 EM_MAX_SLOTS = 8, 236 EM_MAX_RETRY = 5, 237 238 /* em_ctl bits */ 239 EM_CTL_RST = (1 << 9), /* Reset */ 240 EM_CTL_TM = (1 << 8), /* Transmit Message */ 241 EM_CTL_ALHD = (1 << 26), /* Activity LED */ 242 }; 243 244 struct ahci_cmd_hdr { 245 __le32 opts; 246 __le32 status; 247 __le32 tbl_addr; 248 __le32 tbl_addr_hi; 249 __le32 reserved[4]; 250 }; 251 252 struct ahci_sg { 253 __le32 addr; 254 __le32 addr_hi; 255 __le32 reserved; 256 __le32 flags_size; 257 }; 258 259 struct ahci_em_priv { 260 enum sw_activity blink_policy; 261 struct timer_list timer; 262 unsigned long saved_activity; 263 unsigned long activity; 264 unsigned long led_state; 265 }; 266 267 struct ahci_host_priv { 268 unsigned int flags; /* AHCI_HFLAG_* */ 269 u32 cap; /* cap to use */ 270 u32 port_map; /* port map to use */ 271 u32 saved_cap; /* saved initial cap */ 272 u32 saved_port_map; /* saved initial port_map */ 273 u32 em_loc; /* enclosure management location */ 274 }; 275 276 struct ahci_port_priv { 277 struct ata_link *active_link; 278 struct ahci_cmd_hdr *cmd_slot; 279 dma_addr_t cmd_slot_dma; 280 void *cmd_tbl; 281 dma_addr_t cmd_tbl_dma; 282 void *rx_fis; 283 dma_addr_t rx_fis_dma; 284 /* for NCQ spurious interrupt analysis */ 285 unsigned int ncq_saw_d2h:1; 286 unsigned int ncq_saw_dmas:1; 287 unsigned int ncq_saw_sdb:1; 288 u32 intr_mask; /* interrupts to enable */ 289 /* enclosure management info per PM slot */ 290 struct ahci_em_priv em_priv[EM_MAX_SLOTS]; 291 }; 292 293 static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val); 294 static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val); 295 static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent); 296 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc); 297 static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc); 298 static int ahci_port_start(struct ata_port *ap); 299 static void ahci_port_stop(struct ata_port *ap); 300 static void ahci_qc_prep(struct ata_queued_cmd *qc); 301 static void ahci_freeze(struct ata_port *ap); 302 static void ahci_thaw(struct ata_port *ap); 303 static void ahci_pmp_attach(struct ata_port *ap); 304 static void ahci_pmp_detach(struct ata_port *ap); 305 static int ahci_softreset(struct ata_link *link, unsigned int *class, 306 unsigned long deadline); 307 static int ahci_sb600_softreset(struct ata_link *link, unsigned int *class, 308 unsigned long deadline); 309 static int ahci_hardreset(struct ata_link *link, unsigned int *class, 310 unsigned long deadline); 311 static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class, 312 unsigned long deadline); 313 static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class, 314 unsigned long deadline); 315 static void ahci_postreset(struct ata_link *link, unsigned int *class); 316 static void ahci_error_handler(struct ata_port *ap); 317 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc); 318 static int ahci_port_resume(struct ata_port *ap); 319 static void ahci_dev_config(struct ata_device *dev); 320 static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag, 321 u32 opts); 322 #ifdef CONFIG_PM 323 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg); 324 static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg); 325 static int ahci_pci_device_resume(struct pci_dev *pdev); 326 #endif 327 static ssize_t ahci_activity_show(struct ata_device *dev, char *buf); 328 static ssize_t ahci_activity_store(struct ata_device *dev, 329 enum sw_activity val); 330 static void ahci_init_sw_activity(struct ata_link *link); 331 332 static struct device_attribute *ahci_shost_attrs[] = { 333 &dev_attr_link_power_management_policy, 334 &dev_attr_em_message_type, 335 &dev_attr_em_message, 336 NULL 337 }; 338 339 static struct device_attribute *ahci_sdev_attrs[] = { 340 &dev_attr_sw_activity, 341 &dev_attr_unload_heads, 342 NULL 343 }; 344 345 static struct scsi_host_template ahci_sht = { 346 ATA_NCQ_SHT(DRV_NAME), 347 .can_queue = AHCI_MAX_CMDS - 1, 348 .sg_tablesize = AHCI_MAX_SG, 349 .dma_boundary = AHCI_DMA_BOUNDARY, 350 .shost_attrs = ahci_shost_attrs, 351 .sdev_attrs = ahci_sdev_attrs, 352 }; 353 354 static struct ata_port_operations ahci_ops = { 355 .inherits = &sata_pmp_port_ops, 356 357 .qc_defer = sata_pmp_qc_defer_cmd_switch, 358 .qc_prep = ahci_qc_prep, 359 .qc_issue = ahci_qc_issue, 360 .qc_fill_rtf = ahci_qc_fill_rtf, 361 362 .freeze = ahci_freeze, 363 .thaw = ahci_thaw, 364 .softreset = ahci_softreset, 365 .hardreset = ahci_hardreset, 366 .postreset = ahci_postreset, 367 .pmp_softreset = ahci_softreset, 368 .error_handler = ahci_error_handler, 369 .post_internal_cmd = ahci_post_internal_cmd, 370 .dev_config = ahci_dev_config, 371 372 .scr_read = ahci_scr_read, 373 .scr_write = ahci_scr_write, 374 .pmp_attach = ahci_pmp_attach, 375 .pmp_detach = ahci_pmp_detach, 376 377 .enable_pm = ahci_enable_alpm, 378 .disable_pm = ahci_disable_alpm, 379 .em_show = ahci_led_show, 380 .em_store = ahci_led_store, 381 .sw_activity_show = ahci_activity_show, 382 .sw_activity_store = ahci_activity_store, 383 #ifdef CONFIG_PM 384 .port_suspend = ahci_port_suspend, 385 .port_resume = ahci_port_resume, 386 #endif 387 .port_start = ahci_port_start, 388 .port_stop = ahci_port_stop, 389 }; 390 391 static struct ata_port_operations ahci_vt8251_ops = { 392 .inherits = &ahci_ops, 393 .hardreset = ahci_vt8251_hardreset, 394 }; 395 396 static struct ata_port_operations ahci_p5wdh_ops = { 397 .inherits = &ahci_ops, 398 .hardreset = ahci_p5wdh_hardreset, 399 }; 400 401 static struct ata_port_operations ahci_sb600_ops = { 402 .inherits = &ahci_ops, 403 .softreset = ahci_sb600_softreset, 404 .pmp_softreset = ahci_sb600_softreset, 405 }; 406 407 #define AHCI_HFLAGS(flags) .private_data = (void *)(flags) 408 409 static const struct ata_port_info ahci_port_info[] = { 410 [board_ahci] = 411 { 412 .flags = AHCI_FLAG_COMMON, 413 .pio_mask = ATA_PIO4, 414 .udma_mask = ATA_UDMA6, 415 .port_ops = &ahci_ops, 416 }, 417 [board_ahci_vt8251] = 418 { 419 AHCI_HFLAGS (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_PMP), 420 .flags = AHCI_FLAG_COMMON, 421 .pio_mask = ATA_PIO4, 422 .udma_mask = ATA_UDMA6, 423 .port_ops = &ahci_vt8251_ops, 424 }, 425 [board_ahci_ign_iferr] = 426 { 427 AHCI_HFLAGS (AHCI_HFLAG_IGN_IRQ_IF_ERR), 428 .flags = AHCI_FLAG_COMMON, 429 .pio_mask = ATA_PIO4, 430 .udma_mask = ATA_UDMA6, 431 .port_ops = &ahci_ops, 432 }, 433 [board_ahci_sb600] = 434 { 435 AHCI_HFLAGS (AHCI_HFLAG_IGN_SERR_INTERNAL | 436 AHCI_HFLAG_NO_MSI | AHCI_HFLAG_SECT255), 437 .flags = AHCI_FLAG_COMMON, 438 .pio_mask = ATA_PIO4, 439 .udma_mask = ATA_UDMA6, 440 .port_ops = &ahci_sb600_ops, 441 }, 442 [board_ahci_mv] = 443 { 444 AHCI_HFLAGS (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_MSI | 445 AHCI_HFLAG_MV_PATA | AHCI_HFLAG_NO_PMP), 446 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY | 447 ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA, 448 .pio_mask = ATA_PIO4, 449 .udma_mask = ATA_UDMA6, 450 .port_ops = &ahci_ops, 451 }, 452 [board_ahci_sb700] = /* for SB700 and SB800 */ 453 { 454 AHCI_HFLAGS (AHCI_HFLAG_IGN_SERR_INTERNAL), 455 .flags = AHCI_FLAG_COMMON, 456 .pio_mask = ATA_PIO4, 457 .udma_mask = ATA_UDMA6, 458 .port_ops = &ahci_sb600_ops, 459 }, 460 [board_ahci_mcp65] = 461 { 462 AHCI_HFLAGS (AHCI_HFLAG_YES_NCQ), 463 .flags = AHCI_FLAG_COMMON, 464 .pio_mask = ATA_PIO4, 465 .udma_mask = ATA_UDMA6, 466 .port_ops = &ahci_ops, 467 }, 468 [board_ahci_nopmp] = 469 { 470 AHCI_HFLAGS (AHCI_HFLAG_NO_PMP), 471 .flags = AHCI_FLAG_COMMON, 472 .pio_mask = ATA_PIO4, 473 .udma_mask = ATA_UDMA6, 474 .port_ops = &ahci_ops, 475 }, 476 /* board_ahci_yesncq */ 477 { 478 AHCI_HFLAGS (AHCI_HFLAG_YES_NCQ), 479 .flags = AHCI_FLAG_COMMON, 480 .pio_mask = ATA_PIO4, 481 .udma_mask = ATA_UDMA6, 482 .port_ops = &ahci_ops, 483 }, 484 }; 485 486 static const struct pci_device_id ahci_pci_tbl[] = { 487 /* Intel */ 488 { PCI_VDEVICE(INTEL, 0x2652), board_ahci }, /* ICH6 */ 489 { PCI_VDEVICE(INTEL, 0x2653), board_ahci }, /* ICH6M */ 490 { PCI_VDEVICE(INTEL, 0x27c1), board_ahci }, /* ICH7 */ 491 { PCI_VDEVICE(INTEL, 0x27c5), board_ahci }, /* ICH7M */ 492 { PCI_VDEVICE(INTEL, 0x27c3), board_ahci }, /* ICH7R */ 493 { PCI_VDEVICE(AL, 0x5288), board_ahci_ign_iferr }, /* ULi M5288 */ 494 { PCI_VDEVICE(INTEL, 0x2681), board_ahci }, /* ESB2 */ 495 { PCI_VDEVICE(INTEL, 0x2682), board_ahci }, /* ESB2 */ 496 { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */ 497 { PCI_VDEVICE(INTEL, 0x27c6), board_ahci }, /* ICH7-M DH */ 498 { PCI_VDEVICE(INTEL, 0x2821), board_ahci }, /* ICH8 */ 499 { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* ICH8 */ 500 { PCI_VDEVICE(INTEL, 0x2824), board_ahci }, /* ICH8 */ 501 { PCI_VDEVICE(INTEL, 0x2829), board_ahci }, /* ICH8M */ 502 { PCI_VDEVICE(INTEL, 0x282a), board_ahci }, /* ICH8M */ 503 { PCI_VDEVICE(INTEL, 0x2922), board_ahci }, /* ICH9 */ 504 { PCI_VDEVICE(INTEL, 0x2923), board_ahci }, /* ICH9 */ 505 { PCI_VDEVICE(INTEL, 0x2924), board_ahci }, /* ICH9 */ 506 { PCI_VDEVICE(INTEL, 0x2925), board_ahci }, /* ICH9 */ 507 { PCI_VDEVICE(INTEL, 0x2927), board_ahci }, /* ICH9 */ 508 { PCI_VDEVICE(INTEL, 0x2929), board_ahci }, /* ICH9M */ 509 { PCI_VDEVICE(INTEL, 0x292a), board_ahci }, /* ICH9M */ 510 { PCI_VDEVICE(INTEL, 0x292b), board_ahci }, /* ICH9M */ 511 { PCI_VDEVICE(INTEL, 0x292c), board_ahci }, /* ICH9M */ 512 { PCI_VDEVICE(INTEL, 0x292f), board_ahci }, /* ICH9M */ 513 { PCI_VDEVICE(INTEL, 0x294d), board_ahci }, /* ICH9 */ 514 { PCI_VDEVICE(INTEL, 0x294e), board_ahci }, /* ICH9M */ 515 { PCI_VDEVICE(INTEL, 0x502a), board_ahci }, /* Tolapai */ 516 { PCI_VDEVICE(INTEL, 0x502b), board_ahci }, /* Tolapai */ 517 { PCI_VDEVICE(INTEL, 0x3a05), board_ahci }, /* ICH10 */ 518 { PCI_VDEVICE(INTEL, 0x3a22), board_ahci }, /* ICH10 */ 519 { PCI_VDEVICE(INTEL, 0x3a25), board_ahci }, /* ICH10 */ 520 { PCI_VDEVICE(INTEL, 0x3b22), board_ahci }, /* PCH AHCI */ 521 { PCI_VDEVICE(INTEL, 0x3b23), board_ahci }, /* PCH AHCI */ 522 { PCI_VDEVICE(INTEL, 0x3b24), board_ahci }, /* PCH RAID */ 523 { PCI_VDEVICE(INTEL, 0x3b25), board_ahci }, /* PCH RAID */ 524 { PCI_VDEVICE(INTEL, 0x3b29), board_ahci }, /* PCH AHCI */ 525 { PCI_VDEVICE(INTEL, 0x3b2b), board_ahci }, /* PCH RAID */ 526 { PCI_VDEVICE(INTEL, 0x3b2c), board_ahci }, /* PCH RAID */ 527 { PCI_VDEVICE(INTEL, 0x3b2f), board_ahci }, /* PCH AHCI */ 528 529 /* JMicron 360/1/3/5/6, match class to avoid IDE function */ 530 { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 531 PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff, board_ahci_ign_iferr }, 532 533 /* ATI */ 534 { PCI_VDEVICE(ATI, 0x4380), board_ahci_sb600 }, /* ATI SB600 */ 535 { PCI_VDEVICE(ATI, 0x4390), board_ahci_sb700 }, /* ATI SB700/800 */ 536 { PCI_VDEVICE(ATI, 0x4391), board_ahci_sb700 }, /* ATI SB700/800 */ 537 { PCI_VDEVICE(ATI, 0x4392), board_ahci_sb700 }, /* ATI SB700/800 */ 538 { PCI_VDEVICE(ATI, 0x4393), board_ahci_sb700 }, /* ATI SB700/800 */ 539 { PCI_VDEVICE(ATI, 0x4394), board_ahci_sb700 }, /* ATI SB700/800 */ 540 { PCI_VDEVICE(ATI, 0x4395), board_ahci_sb700 }, /* ATI SB700/800 */ 541 542 /* VIA */ 543 { PCI_VDEVICE(VIA, 0x3349), board_ahci_vt8251 }, /* VIA VT8251 */ 544 { PCI_VDEVICE(VIA, 0x6287), board_ahci_vt8251 }, /* VIA VT8251 */ 545 546 /* NVIDIA */ 547 { PCI_VDEVICE(NVIDIA, 0x044c), board_ahci_mcp65 }, /* MCP65 */ 548 { PCI_VDEVICE(NVIDIA, 0x044d), board_ahci_mcp65 }, /* MCP65 */ 549 { PCI_VDEVICE(NVIDIA, 0x044e), board_ahci_mcp65 }, /* MCP65 */ 550 { PCI_VDEVICE(NVIDIA, 0x044f), board_ahci_mcp65 }, /* MCP65 */ 551 { PCI_VDEVICE(NVIDIA, 0x045c), board_ahci_mcp65 }, /* MCP65 */ 552 { PCI_VDEVICE(NVIDIA, 0x045d), board_ahci_mcp65 }, /* MCP65 */ 553 { PCI_VDEVICE(NVIDIA, 0x045e), board_ahci_mcp65 }, /* MCP65 */ 554 { PCI_VDEVICE(NVIDIA, 0x045f), board_ahci_mcp65 }, /* MCP65 */ 555 { PCI_VDEVICE(NVIDIA, 0x0550), board_ahci_yesncq }, /* MCP67 */ 556 { PCI_VDEVICE(NVIDIA, 0x0551), board_ahci_yesncq }, /* MCP67 */ 557 { PCI_VDEVICE(NVIDIA, 0x0552), board_ahci_yesncq }, /* MCP67 */ 558 { PCI_VDEVICE(NVIDIA, 0x0553), board_ahci_yesncq }, /* MCP67 */ 559 { PCI_VDEVICE(NVIDIA, 0x0554), board_ahci_yesncq }, /* MCP67 */ 560 { PCI_VDEVICE(NVIDIA, 0x0555), board_ahci_yesncq }, /* MCP67 */ 561 { PCI_VDEVICE(NVIDIA, 0x0556), board_ahci_yesncq }, /* MCP67 */ 562 { PCI_VDEVICE(NVIDIA, 0x0557), board_ahci_yesncq }, /* MCP67 */ 563 { PCI_VDEVICE(NVIDIA, 0x0558), board_ahci_yesncq }, /* MCP67 */ 564 { PCI_VDEVICE(NVIDIA, 0x0559), board_ahci_yesncq }, /* MCP67 */ 565 { PCI_VDEVICE(NVIDIA, 0x055a), board_ahci_yesncq }, /* MCP67 */ 566 { PCI_VDEVICE(NVIDIA, 0x055b), board_ahci_yesncq }, /* MCP67 */ 567 { PCI_VDEVICE(NVIDIA, 0x07f0), board_ahci_yesncq }, /* MCP73 */ 568 { PCI_VDEVICE(NVIDIA, 0x07f1), board_ahci_yesncq }, /* MCP73 */ 569 { PCI_VDEVICE(NVIDIA, 0x07f2), board_ahci_yesncq }, /* MCP73 */ 570 { PCI_VDEVICE(NVIDIA, 0x07f3), board_ahci_yesncq }, /* MCP73 */ 571 { PCI_VDEVICE(NVIDIA, 0x07f4), board_ahci_yesncq }, /* MCP73 */ 572 { PCI_VDEVICE(NVIDIA, 0x07f5), board_ahci_yesncq }, /* MCP73 */ 573 { PCI_VDEVICE(NVIDIA, 0x07f6), board_ahci_yesncq }, /* MCP73 */ 574 { PCI_VDEVICE(NVIDIA, 0x07f7), board_ahci_yesncq }, /* MCP73 */ 575 { PCI_VDEVICE(NVIDIA, 0x07f8), board_ahci_yesncq }, /* MCP73 */ 576 { PCI_VDEVICE(NVIDIA, 0x07f9), board_ahci_yesncq }, /* MCP73 */ 577 { PCI_VDEVICE(NVIDIA, 0x07fa), board_ahci_yesncq }, /* MCP73 */ 578 { PCI_VDEVICE(NVIDIA, 0x07fb), board_ahci_yesncq }, /* MCP73 */ 579 { PCI_VDEVICE(NVIDIA, 0x0ad0), board_ahci }, /* MCP77 */ 580 { PCI_VDEVICE(NVIDIA, 0x0ad1), board_ahci }, /* MCP77 */ 581 { PCI_VDEVICE(NVIDIA, 0x0ad2), board_ahci }, /* MCP77 */ 582 { PCI_VDEVICE(NVIDIA, 0x0ad3), board_ahci }, /* MCP77 */ 583 { PCI_VDEVICE(NVIDIA, 0x0ad4), board_ahci }, /* MCP77 */ 584 { PCI_VDEVICE(NVIDIA, 0x0ad5), board_ahci }, /* MCP77 */ 585 { PCI_VDEVICE(NVIDIA, 0x0ad6), board_ahci }, /* MCP77 */ 586 { PCI_VDEVICE(NVIDIA, 0x0ad7), board_ahci }, /* MCP77 */ 587 { PCI_VDEVICE(NVIDIA, 0x0ad8), board_ahci }, /* MCP77 */ 588 { PCI_VDEVICE(NVIDIA, 0x0ad9), board_ahci }, /* MCP77 */ 589 { PCI_VDEVICE(NVIDIA, 0x0ada), board_ahci }, /* MCP77 */ 590 { PCI_VDEVICE(NVIDIA, 0x0adb), board_ahci }, /* MCP77 */ 591 { PCI_VDEVICE(NVIDIA, 0x0ab4), board_ahci }, /* MCP79 */ 592 { PCI_VDEVICE(NVIDIA, 0x0ab5), board_ahci }, /* MCP79 */ 593 { PCI_VDEVICE(NVIDIA, 0x0ab6), board_ahci }, /* MCP79 */ 594 { PCI_VDEVICE(NVIDIA, 0x0ab7), board_ahci }, /* MCP79 */ 595 { PCI_VDEVICE(NVIDIA, 0x0ab8), board_ahci }, /* MCP79 */ 596 { PCI_VDEVICE(NVIDIA, 0x0ab9), board_ahci }, /* MCP79 */ 597 { PCI_VDEVICE(NVIDIA, 0x0aba), board_ahci }, /* MCP79 */ 598 { PCI_VDEVICE(NVIDIA, 0x0abb), board_ahci }, /* MCP79 */ 599 { PCI_VDEVICE(NVIDIA, 0x0abc), board_ahci }, /* MCP79 */ 600 { PCI_VDEVICE(NVIDIA, 0x0abd), board_ahci }, /* MCP79 */ 601 { PCI_VDEVICE(NVIDIA, 0x0abe), board_ahci }, /* MCP79 */ 602 { PCI_VDEVICE(NVIDIA, 0x0abf), board_ahci }, /* MCP79 */ 603 { PCI_VDEVICE(NVIDIA, 0x0d84), board_ahci }, /* MCP89 */ 604 { PCI_VDEVICE(NVIDIA, 0x0d85), board_ahci }, /* MCP89 */ 605 { PCI_VDEVICE(NVIDIA, 0x0d86), board_ahci }, /* MCP89 */ 606 { PCI_VDEVICE(NVIDIA, 0x0d87), board_ahci }, /* MCP89 */ 607 { PCI_VDEVICE(NVIDIA, 0x0d88), board_ahci }, /* MCP89 */ 608 { PCI_VDEVICE(NVIDIA, 0x0d89), board_ahci }, /* MCP89 */ 609 { PCI_VDEVICE(NVIDIA, 0x0d8a), board_ahci }, /* MCP89 */ 610 { PCI_VDEVICE(NVIDIA, 0x0d8b), board_ahci }, /* MCP89 */ 611 { PCI_VDEVICE(NVIDIA, 0x0d8c), board_ahci }, /* MCP89 */ 612 { PCI_VDEVICE(NVIDIA, 0x0d8d), board_ahci }, /* MCP89 */ 613 { PCI_VDEVICE(NVIDIA, 0x0d8e), board_ahci }, /* MCP89 */ 614 { PCI_VDEVICE(NVIDIA, 0x0d8f), board_ahci }, /* MCP89 */ 615 616 /* SiS */ 617 { PCI_VDEVICE(SI, 0x1184), board_ahci }, /* SiS 966 */ 618 { PCI_VDEVICE(SI, 0x1185), board_ahci }, /* SiS 968 */ 619 { PCI_VDEVICE(SI, 0x0186), board_ahci }, /* SiS 968 */ 620 621 /* Marvell */ 622 { PCI_VDEVICE(MARVELL, 0x6145), board_ahci_mv }, /* 6145 */ 623 { PCI_VDEVICE(MARVELL, 0x6121), board_ahci_mv }, /* 6121 */ 624 625 /* Promise */ 626 { PCI_VDEVICE(PROMISE, 0x3f20), board_ahci }, /* PDC42819 */ 627 628 /* Generic, PCI class code for AHCI */ 629 { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 630 PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff, board_ahci }, 631 632 { } /* terminate list */ 633 }; 634 635 636 static struct pci_driver ahci_pci_driver = { 637 .name = DRV_NAME, 638 .id_table = ahci_pci_tbl, 639 .probe = ahci_init_one, 640 .remove = ata_pci_remove_one, 641 #ifdef CONFIG_PM 642 .suspend = ahci_pci_device_suspend, 643 .resume = ahci_pci_device_resume, 644 #endif 645 }; 646 647 static int ahci_em_messages = 1; 648 module_param(ahci_em_messages, int, 0444); 649 /* add other LED protocol types when they become supported */ 650 MODULE_PARM_DESC(ahci_em_messages, 651 "Set AHCI Enclosure Management Message type (0 = disabled, 1 = LED"); 652 653 #if defined(CONFIG_PATA_MARVELL) || defined(CONFIG_PATA_MARVELL_MODULE) 654 static int marvell_enable; 655 #else 656 static int marvell_enable = 1; 657 #endif 658 module_param(marvell_enable, int, 0644); 659 MODULE_PARM_DESC(marvell_enable, "Marvell SATA via AHCI (1 = enabled)"); 660 661 662 static inline int ahci_nr_ports(u32 cap) 663 { 664 return (cap & 0x1f) + 1; 665 } 666 667 static inline void __iomem *__ahci_port_base(struct ata_host *host, 668 unsigned int port_no) 669 { 670 void __iomem *mmio = host->iomap[AHCI_PCI_BAR]; 671 672 return mmio + 0x100 + (port_no * 0x80); 673 } 674 675 static inline void __iomem *ahci_port_base(struct ata_port *ap) 676 { 677 return __ahci_port_base(ap->host, ap->port_no); 678 } 679 680 static void ahci_enable_ahci(void __iomem *mmio) 681 { 682 int i; 683 u32 tmp; 684 685 /* turn on AHCI_EN */ 686 tmp = readl(mmio + HOST_CTL); 687 if (tmp & HOST_AHCI_EN) 688 return; 689 690 /* Some controllers need AHCI_EN to be written multiple times. 691 * Try a few times before giving up. 692 */ 693 for (i = 0; i < 5; i++) { 694 tmp |= HOST_AHCI_EN; 695 writel(tmp, mmio + HOST_CTL); 696 tmp = readl(mmio + HOST_CTL); /* flush && sanity check */ 697 if (tmp & HOST_AHCI_EN) 698 return; 699 msleep(10); 700 } 701 702 WARN_ON(1); 703 } 704 705 /** 706 * ahci_save_initial_config - Save and fixup initial config values 707 * @pdev: target PCI device 708 * @hpriv: host private area to store config values 709 * 710 * Some registers containing configuration info might be setup by 711 * BIOS and might be cleared on reset. This function saves the 712 * initial values of those registers into @hpriv such that they 713 * can be restored after controller reset. 714 * 715 * If inconsistent, config values are fixed up by this function. 716 * 717 * LOCKING: 718 * None. 719 */ 720 static void ahci_save_initial_config(struct pci_dev *pdev, 721 struct ahci_host_priv *hpriv) 722 { 723 void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR]; 724 u32 cap, port_map; 725 int i; 726 int mv; 727 728 /* make sure AHCI mode is enabled before accessing CAP */ 729 ahci_enable_ahci(mmio); 730 731 /* Values prefixed with saved_ are written back to host after 732 * reset. Values without are used for driver operation. 733 */ 734 hpriv->saved_cap = cap = readl(mmio + HOST_CAP); 735 hpriv->saved_port_map = port_map = readl(mmio + HOST_PORTS_IMPL); 736 737 /* some chips have errata preventing 64bit use */ 738 if ((cap & HOST_CAP_64) && (hpriv->flags & AHCI_HFLAG_32BIT_ONLY)) { 739 dev_printk(KERN_INFO, &pdev->dev, 740 "controller can't do 64bit DMA, forcing 32bit\n"); 741 cap &= ~HOST_CAP_64; 742 } 743 744 if ((cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_NO_NCQ)) { 745 dev_printk(KERN_INFO, &pdev->dev, 746 "controller can't do NCQ, turning off CAP_NCQ\n"); 747 cap &= ~HOST_CAP_NCQ; 748 } 749 750 if (!(cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_YES_NCQ)) { 751 dev_printk(KERN_INFO, &pdev->dev, 752 "controller can do NCQ, turning on CAP_NCQ\n"); 753 cap |= HOST_CAP_NCQ; 754 } 755 756 if ((cap & HOST_CAP_PMP) && (hpriv->flags & AHCI_HFLAG_NO_PMP)) { 757 dev_printk(KERN_INFO, &pdev->dev, 758 "controller can't do PMP, turning off CAP_PMP\n"); 759 cap &= ~HOST_CAP_PMP; 760 } 761 762 if (pdev->vendor == PCI_VENDOR_ID_JMICRON && pdev->device == 0x2361 && 763 port_map != 1) { 764 dev_printk(KERN_INFO, &pdev->dev, 765 "JMB361 has only one port, port_map 0x%x -> 0x%x\n", 766 port_map, 1); 767 port_map = 1; 768 } 769 770 /* 771 * Temporary Marvell 6145 hack: PATA port presence 772 * is asserted through the standard AHCI port 773 * presence register, as bit 4 (counting from 0) 774 */ 775 if (hpriv->flags & AHCI_HFLAG_MV_PATA) { 776 if (pdev->device == 0x6121) 777 mv = 0x3; 778 else 779 mv = 0xf; 780 dev_printk(KERN_ERR, &pdev->dev, 781 "MV_AHCI HACK: port_map %x -> %x\n", 782 port_map, 783 port_map & mv); 784 dev_printk(KERN_ERR, &pdev->dev, 785 "Disabling your PATA port. Use the boot option 'ahci.marvell_enable=0' to avoid this.\n"); 786 787 port_map &= mv; 788 } 789 790 /* cross check port_map and cap.n_ports */ 791 if (port_map) { 792 int map_ports = 0; 793 794 for (i = 0; i < AHCI_MAX_PORTS; i++) 795 if (port_map & (1 << i)) 796 map_ports++; 797 798 /* If PI has more ports than n_ports, whine, clear 799 * port_map and let it be generated from n_ports. 800 */ 801 if (map_ports > ahci_nr_ports(cap)) { 802 dev_printk(KERN_WARNING, &pdev->dev, 803 "implemented port map (0x%x) contains more " 804 "ports than nr_ports (%u), using nr_ports\n", 805 port_map, ahci_nr_ports(cap)); 806 port_map = 0; 807 } 808 } 809 810 /* fabricate port_map from cap.nr_ports */ 811 if (!port_map) { 812 port_map = (1 << ahci_nr_ports(cap)) - 1; 813 dev_printk(KERN_WARNING, &pdev->dev, 814 "forcing PORTS_IMPL to 0x%x\n", port_map); 815 816 /* write the fixed up value to the PI register */ 817 hpriv->saved_port_map = port_map; 818 } 819 820 /* record values to use during operation */ 821 hpriv->cap = cap; 822 hpriv->port_map = port_map; 823 } 824 825 /** 826 * ahci_restore_initial_config - Restore initial config 827 * @host: target ATA host 828 * 829 * Restore initial config stored by ahci_save_initial_config(). 830 * 831 * LOCKING: 832 * None. 833 */ 834 static void ahci_restore_initial_config(struct ata_host *host) 835 { 836 struct ahci_host_priv *hpriv = host->private_data; 837 void __iomem *mmio = host->iomap[AHCI_PCI_BAR]; 838 839 writel(hpriv->saved_cap, mmio + HOST_CAP); 840 writel(hpriv->saved_port_map, mmio + HOST_PORTS_IMPL); 841 (void) readl(mmio + HOST_PORTS_IMPL); /* flush */ 842 } 843 844 static unsigned ahci_scr_offset(struct ata_port *ap, unsigned int sc_reg) 845 { 846 static const int offset[] = { 847 [SCR_STATUS] = PORT_SCR_STAT, 848 [SCR_CONTROL] = PORT_SCR_CTL, 849 [SCR_ERROR] = PORT_SCR_ERR, 850 [SCR_ACTIVE] = PORT_SCR_ACT, 851 [SCR_NOTIFICATION] = PORT_SCR_NTF, 852 }; 853 struct ahci_host_priv *hpriv = ap->host->private_data; 854 855 if (sc_reg < ARRAY_SIZE(offset) && 856 (sc_reg != SCR_NOTIFICATION || (hpriv->cap & HOST_CAP_SNTF))) 857 return offset[sc_reg]; 858 return 0; 859 } 860 861 static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val) 862 { 863 void __iomem *port_mmio = ahci_port_base(link->ap); 864 int offset = ahci_scr_offset(link->ap, sc_reg); 865 866 if (offset) { 867 *val = readl(port_mmio + offset); 868 return 0; 869 } 870 return -EINVAL; 871 } 872 873 static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val) 874 { 875 void __iomem *port_mmio = ahci_port_base(link->ap); 876 int offset = ahci_scr_offset(link->ap, sc_reg); 877 878 if (offset) { 879 writel(val, port_mmio + offset); 880 return 0; 881 } 882 return -EINVAL; 883 } 884 885 static void ahci_start_engine(struct ata_port *ap) 886 { 887 void __iomem *port_mmio = ahci_port_base(ap); 888 u32 tmp; 889 890 /* start DMA */ 891 tmp = readl(port_mmio + PORT_CMD); 892 tmp |= PORT_CMD_START; 893 writel(tmp, port_mmio + PORT_CMD); 894 readl(port_mmio + PORT_CMD); /* flush */ 895 } 896 897 static int ahci_stop_engine(struct ata_port *ap) 898 { 899 void __iomem *port_mmio = ahci_port_base(ap); 900 u32 tmp; 901 902 tmp = readl(port_mmio + PORT_CMD); 903 904 /* check if the HBA is idle */ 905 if ((tmp & (PORT_CMD_START | PORT_CMD_LIST_ON)) == 0) 906 return 0; 907 908 /* setting HBA to idle */ 909 tmp &= ~PORT_CMD_START; 910 writel(tmp, port_mmio + PORT_CMD); 911 912 /* wait for engine to stop. This could be as long as 500 msec */ 913 tmp = ata_wait_register(port_mmio + PORT_CMD, 914 PORT_CMD_LIST_ON, PORT_CMD_LIST_ON, 1, 500); 915 if (tmp & PORT_CMD_LIST_ON) 916 return -EIO; 917 918 return 0; 919 } 920 921 static void ahci_start_fis_rx(struct ata_port *ap) 922 { 923 void __iomem *port_mmio = ahci_port_base(ap); 924 struct ahci_host_priv *hpriv = ap->host->private_data; 925 struct ahci_port_priv *pp = ap->private_data; 926 u32 tmp; 927 928 /* set FIS registers */ 929 if (hpriv->cap & HOST_CAP_64) 930 writel((pp->cmd_slot_dma >> 16) >> 16, 931 port_mmio + PORT_LST_ADDR_HI); 932 writel(pp->cmd_slot_dma & 0xffffffff, port_mmio + PORT_LST_ADDR); 933 934 if (hpriv->cap & HOST_CAP_64) 935 writel((pp->rx_fis_dma >> 16) >> 16, 936 port_mmio + PORT_FIS_ADDR_HI); 937 writel(pp->rx_fis_dma & 0xffffffff, port_mmio + PORT_FIS_ADDR); 938 939 /* enable FIS reception */ 940 tmp = readl(port_mmio + PORT_CMD); 941 tmp |= PORT_CMD_FIS_RX; 942 writel(tmp, port_mmio + PORT_CMD); 943 944 /* flush */ 945 readl(port_mmio + PORT_CMD); 946 } 947 948 static int ahci_stop_fis_rx(struct ata_port *ap) 949 { 950 void __iomem *port_mmio = ahci_port_base(ap); 951 u32 tmp; 952 953 /* disable FIS reception */ 954 tmp = readl(port_mmio + PORT_CMD); 955 tmp &= ~PORT_CMD_FIS_RX; 956 writel(tmp, port_mmio + PORT_CMD); 957 958 /* wait for completion, spec says 500ms, give it 1000 */ 959 tmp = ata_wait_register(port_mmio + PORT_CMD, PORT_CMD_FIS_ON, 960 PORT_CMD_FIS_ON, 10, 1000); 961 if (tmp & PORT_CMD_FIS_ON) 962 return -EBUSY; 963 964 return 0; 965 } 966 967 static void ahci_power_up(struct ata_port *ap) 968 { 969 struct ahci_host_priv *hpriv = ap->host->private_data; 970 void __iomem *port_mmio = ahci_port_base(ap); 971 u32 cmd; 972 973 cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK; 974 975 /* spin up device */ 976 if (hpriv->cap & HOST_CAP_SSS) { 977 cmd |= PORT_CMD_SPIN_UP; 978 writel(cmd, port_mmio + PORT_CMD); 979 } 980 981 /* wake up link */ 982 writel(cmd | PORT_CMD_ICC_ACTIVE, port_mmio + PORT_CMD); 983 } 984 985 static void ahci_disable_alpm(struct ata_port *ap) 986 { 987 struct ahci_host_priv *hpriv = ap->host->private_data; 988 void __iomem *port_mmio = ahci_port_base(ap); 989 u32 cmd; 990 struct ahci_port_priv *pp = ap->private_data; 991 992 /* IPM bits should be disabled by libata-core */ 993 /* get the existing command bits */ 994 cmd = readl(port_mmio + PORT_CMD); 995 996 /* disable ALPM and ASP */ 997 cmd &= ~PORT_CMD_ASP; 998 cmd &= ~PORT_CMD_ALPE; 999 1000 /* force the interface back to active */ 1001 cmd |= PORT_CMD_ICC_ACTIVE; 1002 1003 /* write out new cmd value */ 1004 writel(cmd, port_mmio + PORT_CMD); 1005 cmd = readl(port_mmio + PORT_CMD); 1006 1007 /* wait 10ms to be sure we've come out of any low power state */ 1008 msleep(10); 1009 1010 /* clear out any PhyRdy stuff from interrupt status */ 1011 writel(PORT_IRQ_PHYRDY, port_mmio + PORT_IRQ_STAT); 1012 1013 /* go ahead and clean out PhyRdy Change from Serror too */ 1014 ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18))); 1015 1016 /* 1017 * Clear flag to indicate that we should ignore all PhyRdy 1018 * state changes 1019 */ 1020 hpriv->flags &= ~AHCI_HFLAG_NO_HOTPLUG; 1021 1022 /* 1023 * Enable interrupts on Phy Ready. 1024 */ 1025 pp->intr_mask |= PORT_IRQ_PHYRDY; 1026 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK); 1027 1028 /* 1029 * don't change the link pm policy - we can be called 1030 * just to turn of link pm temporarily 1031 */ 1032 } 1033 1034 static int ahci_enable_alpm(struct ata_port *ap, 1035 enum link_pm policy) 1036 { 1037 struct ahci_host_priv *hpriv = ap->host->private_data; 1038 void __iomem *port_mmio = ahci_port_base(ap); 1039 u32 cmd; 1040 struct ahci_port_priv *pp = ap->private_data; 1041 u32 asp; 1042 1043 /* Make sure the host is capable of link power management */ 1044 if (!(hpriv->cap & HOST_CAP_ALPM)) 1045 return -EINVAL; 1046 1047 switch (policy) { 1048 case MAX_PERFORMANCE: 1049 case NOT_AVAILABLE: 1050 /* 1051 * if we came here with NOT_AVAILABLE, 1052 * it just means this is the first time we 1053 * have tried to enable - default to max performance, 1054 * and let the user go to lower power modes on request. 1055 */ 1056 ahci_disable_alpm(ap); 1057 return 0; 1058 case MIN_POWER: 1059 /* configure HBA to enter SLUMBER */ 1060 asp = PORT_CMD_ASP; 1061 break; 1062 case MEDIUM_POWER: 1063 /* configure HBA to enter PARTIAL */ 1064 asp = 0; 1065 break; 1066 default: 1067 return -EINVAL; 1068 } 1069 1070 /* 1071 * Disable interrupts on Phy Ready. This keeps us from 1072 * getting woken up due to spurious phy ready interrupts 1073 * TBD - Hot plug should be done via polling now, is 1074 * that even supported? 1075 */ 1076 pp->intr_mask &= ~PORT_IRQ_PHYRDY; 1077 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK); 1078 1079 /* 1080 * Set a flag to indicate that we should ignore all PhyRdy 1081 * state changes since these can happen now whenever we 1082 * change link state 1083 */ 1084 hpriv->flags |= AHCI_HFLAG_NO_HOTPLUG; 1085 1086 /* get the existing command bits */ 1087 cmd = readl(port_mmio + PORT_CMD); 1088 1089 /* 1090 * Set ASP based on Policy 1091 */ 1092 cmd |= asp; 1093 1094 /* 1095 * Setting this bit will instruct the HBA to aggressively 1096 * enter a lower power link state when it's appropriate and 1097 * based on the value set above for ASP 1098 */ 1099 cmd |= PORT_CMD_ALPE; 1100 1101 /* write out new cmd value */ 1102 writel(cmd, port_mmio + PORT_CMD); 1103 cmd = readl(port_mmio + PORT_CMD); 1104 1105 /* IPM bits should be set by libata-core */ 1106 return 0; 1107 } 1108 1109 #ifdef CONFIG_PM 1110 static void ahci_power_down(struct ata_port *ap) 1111 { 1112 struct ahci_host_priv *hpriv = ap->host->private_data; 1113 void __iomem *port_mmio = ahci_port_base(ap); 1114 u32 cmd, scontrol; 1115 1116 if (!(hpriv->cap & HOST_CAP_SSS)) 1117 return; 1118 1119 /* put device into listen mode, first set PxSCTL.DET to 0 */ 1120 scontrol = readl(port_mmio + PORT_SCR_CTL); 1121 scontrol &= ~0xf; 1122 writel(scontrol, port_mmio + PORT_SCR_CTL); 1123 1124 /* then set PxCMD.SUD to 0 */ 1125 cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK; 1126 cmd &= ~PORT_CMD_SPIN_UP; 1127 writel(cmd, port_mmio + PORT_CMD); 1128 } 1129 #endif 1130 1131 static void ahci_start_port(struct ata_port *ap) 1132 { 1133 struct ahci_port_priv *pp = ap->private_data; 1134 struct ata_link *link; 1135 struct ahci_em_priv *emp; 1136 ssize_t rc; 1137 int i; 1138 1139 /* enable FIS reception */ 1140 ahci_start_fis_rx(ap); 1141 1142 /* enable DMA */ 1143 ahci_start_engine(ap); 1144 1145 /* turn on LEDs */ 1146 if (ap->flags & ATA_FLAG_EM) { 1147 ata_for_each_link(link, ap, EDGE) { 1148 emp = &pp->em_priv[link->pmp]; 1149 1150 /* EM Transmit bit maybe busy during init */ 1151 for (i = 0; i < EM_MAX_RETRY; i++) { 1152 rc = ahci_transmit_led_message(ap, 1153 emp->led_state, 1154 4); 1155 if (rc == -EBUSY) 1156 msleep(1); 1157 else 1158 break; 1159 } 1160 } 1161 } 1162 1163 if (ap->flags & ATA_FLAG_SW_ACTIVITY) 1164 ata_for_each_link(link, ap, EDGE) 1165 ahci_init_sw_activity(link); 1166 1167 } 1168 1169 static int ahci_deinit_port(struct ata_port *ap, const char **emsg) 1170 { 1171 int rc; 1172 1173 /* disable DMA */ 1174 rc = ahci_stop_engine(ap); 1175 if (rc) { 1176 *emsg = "failed to stop engine"; 1177 return rc; 1178 } 1179 1180 /* disable FIS reception */ 1181 rc = ahci_stop_fis_rx(ap); 1182 if (rc) { 1183 *emsg = "failed stop FIS RX"; 1184 return rc; 1185 } 1186 1187 return 0; 1188 } 1189 1190 static int ahci_reset_controller(struct ata_host *host) 1191 { 1192 struct pci_dev *pdev = to_pci_dev(host->dev); 1193 struct ahci_host_priv *hpriv = host->private_data; 1194 void __iomem *mmio = host->iomap[AHCI_PCI_BAR]; 1195 u32 tmp; 1196 1197 /* we must be in AHCI mode, before using anything 1198 * AHCI-specific, such as HOST_RESET. 1199 */ 1200 ahci_enable_ahci(mmio); 1201 1202 /* global controller reset */ 1203 if (!ahci_skip_host_reset) { 1204 tmp = readl(mmio + HOST_CTL); 1205 if ((tmp & HOST_RESET) == 0) { 1206 writel(tmp | HOST_RESET, mmio + HOST_CTL); 1207 readl(mmio + HOST_CTL); /* flush */ 1208 } 1209 1210 /* 1211 * to perform host reset, OS should set HOST_RESET 1212 * and poll until this bit is read to be "0". 1213 * reset must complete within 1 second, or 1214 * the hardware should be considered fried. 1215 */ 1216 tmp = ata_wait_register(mmio + HOST_CTL, HOST_RESET, 1217 HOST_RESET, 10, 1000); 1218 1219 if (tmp & HOST_RESET) { 1220 dev_printk(KERN_ERR, host->dev, 1221 "controller reset failed (0x%x)\n", tmp); 1222 return -EIO; 1223 } 1224 1225 /* turn on AHCI mode */ 1226 ahci_enable_ahci(mmio); 1227 1228 /* Some registers might be cleared on reset. Restore 1229 * initial values. 1230 */ 1231 ahci_restore_initial_config(host); 1232 } else 1233 dev_printk(KERN_INFO, host->dev, 1234 "skipping global host reset\n"); 1235 1236 if (pdev->vendor == PCI_VENDOR_ID_INTEL) { 1237 u16 tmp16; 1238 1239 /* configure PCS */ 1240 pci_read_config_word(pdev, 0x92, &tmp16); 1241 if ((tmp16 & hpriv->port_map) != hpriv->port_map) { 1242 tmp16 |= hpriv->port_map; 1243 pci_write_config_word(pdev, 0x92, tmp16); 1244 } 1245 } 1246 1247 return 0; 1248 } 1249 1250 static void ahci_sw_activity(struct ata_link *link) 1251 { 1252 struct ata_port *ap = link->ap; 1253 struct ahci_port_priv *pp = ap->private_data; 1254 struct ahci_em_priv *emp = &pp->em_priv[link->pmp]; 1255 1256 if (!(link->flags & ATA_LFLAG_SW_ACTIVITY)) 1257 return; 1258 1259 emp->activity++; 1260 if (!timer_pending(&emp->timer)) 1261 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(10)); 1262 } 1263 1264 static void ahci_sw_activity_blink(unsigned long arg) 1265 { 1266 struct ata_link *link = (struct ata_link *)arg; 1267 struct ata_port *ap = link->ap; 1268 struct ahci_port_priv *pp = ap->private_data; 1269 struct ahci_em_priv *emp = &pp->em_priv[link->pmp]; 1270 unsigned long led_message = emp->led_state; 1271 u32 activity_led_state; 1272 unsigned long flags; 1273 1274 led_message &= EM_MSG_LED_VALUE; 1275 led_message |= ap->port_no | (link->pmp << 8); 1276 1277 /* check to see if we've had activity. If so, 1278 * toggle state of LED and reset timer. If not, 1279 * turn LED to desired idle state. 1280 */ 1281 spin_lock_irqsave(ap->lock, flags); 1282 if (emp->saved_activity != emp->activity) { 1283 emp->saved_activity = emp->activity; 1284 /* get the current LED state */ 1285 activity_led_state = led_message & EM_MSG_LED_VALUE_ON; 1286 1287 if (activity_led_state) 1288 activity_led_state = 0; 1289 else 1290 activity_led_state = 1; 1291 1292 /* clear old state */ 1293 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY; 1294 1295 /* toggle state */ 1296 led_message |= (activity_led_state << 16); 1297 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(100)); 1298 } else { 1299 /* switch to idle */ 1300 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY; 1301 if (emp->blink_policy == BLINK_OFF) 1302 led_message |= (1 << 16); 1303 } 1304 spin_unlock_irqrestore(ap->lock, flags); 1305 ahci_transmit_led_message(ap, led_message, 4); 1306 } 1307 1308 static void ahci_init_sw_activity(struct ata_link *link) 1309 { 1310 struct ata_port *ap = link->ap; 1311 struct ahci_port_priv *pp = ap->private_data; 1312 struct ahci_em_priv *emp = &pp->em_priv[link->pmp]; 1313 1314 /* init activity stats, setup timer */ 1315 emp->saved_activity = emp->activity = 0; 1316 setup_timer(&emp->timer, ahci_sw_activity_blink, (unsigned long)link); 1317 1318 /* check our blink policy and set flag for link if it's enabled */ 1319 if (emp->blink_policy) 1320 link->flags |= ATA_LFLAG_SW_ACTIVITY; 1321 } 1322 1323 static int ahci_reset_em(struct ata_host *host) 1324 { 1325 void __iomem *mmio = host->iomap[AHCI_PCI_BAR]; 1326 u32 em_ctl; 1327 1328 em_ctl = readl(mmio + HOST_EM_CTL); 1329 if ((em_ctl & EM_CTL_TM) || (em_ctl & EM_CTL_RST)) 1330 return -EINVAL; 1331 1332 writel(em_ctl | EM_CTL_RST, mmio + HOST_EM_CTL); 1333 return 0; 1334 } 1335 1336 static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state, 1337 ssize_t size) 1338 { 1339 struct ahci_host_priv *hpriv = ap->host->private_data; 1340 struct ahci_port_priv *pp = ap->private_data; 1341 void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR]; 1342 u32 em_ctl; 1343 u32 message[] = {0, 0}; 1344 unsigned long flags; 1345 int pmp; 1346 struct ahci_em_priv *emp; 1347 1348 /* get the slot number from the message */ 1349 pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8; 1350 if (pmp < EM_MAX_SLOTS) 1351 emp = &pp->em_priv[pmp]; 1352 else 1353 return -EINVAL; 1354 1355 spin_lock_irqsave(ap->lock, flags); 1356 1357 /* 1358 * if we are still busy transmitting a previous message, 1359 * do not allow 1360 */ 1361 em_ctl = readl(mmio + HOST_EM_CTL); 1362 if (em_ctl & EM_CTL_TM) { 1363 spin_unlock_irqrestore(ap->lock, flags); 1364 return -EBUSY; 1365 } 1366 1367 /* 1368 * create message header - this is all zero except for 1369 * the message size, which is 4 bytes. 1370 */ 1371 message[0] |= (4 << 8); 1372 1373 /* ignore 0:4 of byte zero, fill in port info yourself */ 1374 message[1] = ((state & ~EM_MSG_LED_HBA_PORT) | ap->port_no); 1375 1376 /* write message to EM_LOC */ 1377 writel(message[0], mmio + hpriv->em_loc); 1378 writel(message[1], mmio + hpriv->em_loc+4); 1379 1380 /* save off new led state for port/slot */ 1381 emp->led_state = state; 1382 1383 /* 1384 * tell hardware to transmit the message 1385 */ 1386 writel(em_ctl | EM_CTL_TM, mmio + HOST_EM_CTL); 1387 1388 spin_unlock_irqrestore(ap->lock, flags); 1389 return size; 1390 } 1391 1392 static ssize_t ahci_led_show(struct ata_port *ap, char *buf) 1393 { 1394 struct ahci_port_priv *pp = ap->private_data; 1395 struct ata_link *link; 1396 struct ahci_em_priv *emp; 1397 int rc = 0; 1398 1399 ata_for_each_link(link, ap, EDGE) { 1400 emp = &pp->em_priv[link->pmp]; 1401 rc += sprintf(buf, "%lx\n", emp->led_state); 1402 } 1403 return rc; 1404 } 1405 1406 static ssize_t ahci_led_store(struct ata_port *ap, const char *buf, 1407 size_t size) 1408 { 1409 int state; 1410 int pmp; 1411 struct ahci_port_priv *pp = ap->private_data; 1412 struct ahci_em_priv *emp; 1413 1414 state = simple_strtoul(buf, NULL, 0); 1415 1416 /* get the slot number from the message */ 1417 pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8; 1418 if (pmp < EM_MAX_SLOTS) 1419 emp = &pp->em_priv[pmp]; 1420 else 1421 return -EINVAL; 1422 1423 /* mask off the activity bits if we are in sw_activity 1424 * mode, user should turn off sw_activity before setting 1425 * activity led through em_message 1426 */ 1427 if (emp->blink_policy) 1428 state &= ~EM_MSG_LED_VALUE_ACTIVITY; 1429 1430 return ahci_transmit_led_message(ap, state, size); 1431 } 1432 1433 static ssize_t ahci_activity_store(struct ata_device *dev, enum sw_activity val) 1434 { 1435 struct ata_link *link = dev->link; 1436 struct ata_port *ap = link->ap; 1437 struct ahci_port_priv *pp = ap->private_data; 1438 struct ahci_em_priv *emp = &pp->em_priv[link->pmp]; 1439 u32 port_led_state = emp->led_state; 1440 1441 /* save the desired Activity LED behavior */ 1442 if (val == OFF) { 1443 /* clear LFLAG */ 1444 link->flags &= ~(ATA_LFLAG_SW_ACTIVITY); 1445 1446 /* set the LED to OFF */ 1447 port_led_state &= EM_MSG_LED_VALUE_OFF; 1448 port_led_state |= (ap->port_no | (link->pmp << 8)); 1449 ahci_transmit_led_message(ap, port_led_state, 4); 1450 } else { 1451 link->flags |= ATA_LFLAG_SW_ACTIVITY; 1452 if (val == BLINK_OFF) { 1453 /* set LED to ON for idle */ 1454 port_led_state &= EM_MSG_LED_VALUE_OFF; 1455 port_led_state |= (ap->port_no | (link->pmp << 8)); 1456 port_led_state |= EM_MSG_LED_VALUE_ON; /* check this */ 1457 ahci_transmit_led_message(ap, port_led_state, 4); 1458 } 1459 } 1460 emp->blink_policy = val; 1461 return 0; 1462 } 1463 1464 static ssize_t ahci_activity_show(struct ata_device *dev, char *buf) 1465 { 1466 struct ata_link *link = dev->link; 1467 struct ata_port *ap = link->ap; 1468 struct ahci_port_priv *pp = ap->private_data; 1469 struct ahci_em_priv *emp = &pp->em_priv[link->pmp]; 1470 1471 /* display the saved value of activity behavior for this 1472 * disk. 1473 */ 1474 return sprintf(buf, "%d\n", emp->blink_policy); 1475 } 1476 1477 static void ahci_port_init(struct pci_dev *pdev, struct ata_port *ap, 1478 int port_no, void __iomem *mmio, 1479 void __iomem *port_mmio) 1480 { 1481 const char *emsg = NULL; 1482 int rc; 1483 u32 tmp; 1484 1485 /* make sure port is not active */ 1486 rc = ahci_deinit_port(ap, &emsg); 1487 if (rc) 1488 dev_printk(KERN_WARNING, &pdev->dev, 1489 "%s (%d)\n", emsg, rc); 1490 1491 /* clear SError */ 1492 tmp = readl(port_mmio + PORT_SCR_ERR); 1493 VPRINTK("PORT_SCR_ERR 0x%x\n", tmp); 1494 writel(tmp, port_mmio + PORT_SCR_ERR); 1495 1496 /* clear port IRQ */ 1497 tmp = readl(port_mmio + PORT_IRQ_STAT); 1498 VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp); 1499 if (tmp) 1500 writel(tmp, port_mmio + PORT_IRQ_STAT); 1501 1502 writel(1 << port_no, mmio + HOST_IRQ_STAT); 1503 } 1504 1505 static void ahci_init_controller(struct ata_host *host) 1506 { 1507 struct ahci_host_priv *hpriv = host->private_data; 1508 struct pci_dev *pdev = to_pci_dev(host->dev); 1509 void __iomem *mmio = host->iomap[AHCI_PCI_BAR]; 1510 int i; 1511 void __iomem *port_mmio; 1512 u32 tmp; 1513 int mv; 1514 1515 if (hpriv->flags & AHCI_HFLAG_MV_PATA) { 1516 if (pdev->device == 0x6121) 1517 mv = 2; 1518 else 1519 mv = 4; 1520 port_mmio = __ahci_port_base(host, mv); 1521 1522 writel(0, port_mmio + PORT_IRQ_MASK); 1523 1524 /* clear port IRQ */ 1525 tmp = readl(port_mmio + PORT_IRQ_STAT); 1526 VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp); 1527 if (tmp) 1528 writel(tmp, port_mmio + PORT_IRQ_STAT); 1529 } 1530 1531 for (i = 0; i < host->n_ports; i++) { 1532 struct ata_port *ap = host->ports[i]; 1533 1534 port_mmio = ahci_port_base(ap); 1535 if (ata_port_is_dummy(ap)) 1536 continue; 1537 1538 ahci_port_init(pdev, ap, i, mmio, port_mmio); 1539 } 1540 1541 tmp = readl(mmio + HOST_CTL); 1542 VPRINTK("HOST_CTL 0x%x\n", tmp); 1543 writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL); 1544 tmp = readl(mmio + HOST_CTL); 1545 VPRINTK("HOST_CTL 0x%x\n", tmp); 1546 } 1547 1548 static void ahci_dev_config(struct ata_device *dev) 1549 { 1550 struct ahci_host_priv *hpriv = dev->link->ap->host->private_data; 1551 1552 if (hpriv->flags & AHCI_HFLAG_SECT255) { 1553 dev->max_sectors = 255; 1554 ata_dev_printk(dev, KERN_INFO, 1555 "SB600 AHCI: limiting to 255 sectors per cmd\n"); 1556 } 1557 } 1558 1559 static unsigned int ahci_dev_classify(struct ata_port *ap) 1560 { 1561 void __iomem *port_mmio = ahci_port_base(ap); 1562 struct ata_taskfile tf; 1563 u32 tmp; 1564 1565 tmp = readl(port_mmio + PORT_SIG); 1566 tf.lbah = (tmp >> 24) & 0xff; 1567 tf.lbam = (tmp >> 16) & 0xff; 1568 tf.lbal = (tmp >> 8) & 0xff; 1569 tf.nsect = (tmp) & 0xff; 1570 1571 return ata_dev_classify(&tf); 1572 } 1573 1574 static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag, 1575 u32 opts) 1576 { 1577 dma_addr_t cmd_tbl_dma; 1578 1579 cmd_tbl_dma = pp->cmd_tbl_dma + tag * AHCI_CMD_TBL_SZ; 1580 1581 pp->cmd_slot[tag].opts = cpu_to_le32(opts); 1582 pp->cmd_slot[tag].status = 0; 1583 pp->cmd_slot[tag].tbl_addr = cpu_to_le32(cmd_tbl_dma & 0xffffffff); 1584 pp->cmd_slot[tag].tbl_addr_hi = cpu_to_le32((cmd_tbl_dma >> 16) >> 16); 1585 } 1586 1587 static int ahci_kick_engine(struct ata_port *ap, int force_restart) 1588 { 1589 void __iomem *port_mmio = ahci_port_base(ap); 1590 struct ahci_host_priv *hpriv = ap->host->private_data; 1591 u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF; 1592 u32 tmp; 1593 int busy, rc; 1594 1595 /* do we need to kick the port? */ 1596 busy = status & (ATA_BUSY | ATA_DRQ); 1597 if (!busy && !force_restart) 1598 return 0; 1599 1600 /* stop engine */ 1601 rc = ahci_stop_engine(ap); 1602 if (rc) 1603 goto out_restart; 1604 1605 /* need to do CLO? */ 1606 if (!busy) { 1607 rc = 0; 1608 goto out_restart; 1609 } 1610 1611 if (!(hpriv->cap & HOST_CAP_CLO)) { 1612 rc = -EOPNOTSUPP; 1613 goto out_restart; 1614 } 1615 1616 /* perform CLO */ 1617 tmp = readl(port_mmio + PORT_CMD); 1618 tmp |= PORT_CMD_CLO; 1619 writel(tmp, port_mmio + PORT_CMD); 1620 1621 rc = 0; 1622 tmp = ata_wait_register(port_mmio + PORT_CMD, 1623 PORT_CMD_CLO, PORT_CMD_CLO, 1, 500); 1624 if (tmp & PORT_CMD_CLO) 1625 rc = -EIO; 1626 1627 /* restart engine */ 1628 out_restart: 1629 ahci_start_engine(ap); 1630 return rc; 1631 } 1632 1633 static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp, 1634 struct ata_taskfile *tf, int is_cmd, u16 flags, 1635 unsigned long timeout_msec) 1636 { 1637 const u32 cmd_fis_len = 5; /* five dwords */ 1638 struct ahci_port_priv *pp = ap->private_data; 1639 void __iomem *port_mmio = ahci_port_base(ap); 1640 u8 *fis = pp->cmd_tbl; 1641 u32 tmp; 1642 1643 /* prep the command */ 1644 ata_tf_to_fis(tf, pmp, is_cmd, fis); 1645 ahci_fill_cmd_slot(pp, 0, cmd_fis_len | flags | (pmp << 12)); 1646 1647 /* issue & wait */ 1648 writel(1, port_mmio + PORT_CMD_ISSUE); 1649 1650 if (timeout_msec) { 1651 tmp = ata_wait_register(port_mmio + PORT_CMD_ISSUE, 0x1, 0x1, 1652 1, timeout_msec); 1653 if (tmp & 0x1) { 1654 ahci_kick_engine(ap, 1); 1655 return -EBUSY; 1656 } 1657 } else 1658 readl(port_mmio + PORT_CMD_ISSUE); /* flush */ 1659 1660 return 0; 1661 } 1662 1663 static int ahci_do_softreset(struct ata_link *link, unsigned int *class, 1664 int pmp, unsigned long deadline, 1665 int (*check_ready)(struct ata_link *link)) 1666 { 1667 struct ata_port *ap = link->ap; 1668 struct ahci_host_priv *hpriv = ap->host->private_data; 1669 const char *reason = NULL; 1670 unsigned long now, msecs; 1671 struct ata_taskfile tf; 1672 int rc; 1673 1674 DPRINTK("ENTER\n"); 1675 1676 /* prepare for SRST (AHCI-1.1 10.4.1) */ 1677 rc = ahci_kick_engine(ap, 1); 1678 if (rc && rc != -EOPNOTSUPP) 1679 ata_link_printk(link, KERN_WARNING, 1680 "failed to reset engine (errno=%d)\n", rc); 1681 1682 ata_tf_init(link->device, &tf); 1683 1684 /* issue the first D2H Register FIS */ 1685 msecs = 0; 1686 now = jiffies; 1687 if (time_after(now, deadline)) 1688 msecs = jiffies_to_msecs(deadline - now); 1689 1690 tf.ctl |= ATA_SRST; 1691 if (ahci_exec_polled_cmd(ap, pmp, &tf, 0, 1692 AHCI_CMD_RESET | AHCI_CMD_CLR_BUSY, msecs)) { 1693 rc = -EIO; 1694 reason = "1st FIS failed"; 1695 goto fail; 1696 } 1697 1698 /* spec says at least 5us, but be generous and sleep for 1ms */ 1699 msleep(1); 1700 1701 /* issue the second D2H Register FIS */ 1702 tf.ctl &= ~ATA_SRST; 1703 ahci_exec_polled_cmd(ap, pmp, &tf, 0, 0, 0); 1704 1705 /* wait for link to become ready */ 1706 rc = ata_wait_after_reset(link, deadline, check_ready); 1707 if (rc == -EBUSY && hpriv->flags & AHCI_HFLAG_SRST_TOUT_IS_OFFLINE) { 1708 /* 1709 * Workaround for cases where link online status can't 1710 * be trusted. Treat device readiness timeout as link 1711 * offline. 1712 */ 1713 ata_link_printk(link, KERN_INFO, 1714 "device not ready, treating as offline\n"); 1715 *class = ATA_DEV_NONE; 1716 } else if (rc) { 1717 /* link occupied, -ENODEV too is an error */ 1718 reason = "device not ready"; 1719 goto fail; 1720 } else 1721 *class = ahci_dev_classify(ap); 1722 1723 DPRINTK("EXIT, class=%u\n", *class); 1724 return 0; 1725 1726 fail: 1727 ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason); 1728 return rc; 1729 } 1730 1731 static int ahci_check_ready(struct ata_link *link) 1732 { 1733 void __iomem *port_mmio = ahci_port_base(link->ap); 1734 u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF; 1735 1736 return ata_check_ready(status); 1737 } 1738 1739 static int ahci_softreset(struct ata_link *link, unsigned int *class, 1740 unsigned long deadline) 1741 { 1742 int pmp = sata_srst_pmp(link); 1743 1744 DPRINTK("ENTER\n"); 1745 1746 return ahci_do_softreset(link, class, pmp, deadline, ahci_check_ready); 1747 } 1748 1749 static int ahci_sb600_check_ready(struct ata_link *link) 1750 { 1751 void __iomem *port_mmio = ahci_port_base(link->ap); 1752 u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF; 1753 u32 irq_status = readl(port_mmio + PORT_IRQ_STAT); 1754 1755 /* 1756 * There is no need to check TFDATA if BAD PMP is found due to HW bug, 1757 * which can save timeout delay. 1758 */ 1759 if (irq_status & PORT_IRQ_BAD_PMP) 1760 return -EIO; 1761 1762 return ata_check_ready(status); 1763 } 1764 1765 static int ahci_sb600_softreset(struct ata_link *link, unsigned int *class, 1766 unsigned long deadline) 1767 { 1768 struct ata_port *ap = link->ap; 1769 void __iomem *port_mmio = ahci_port_base(ap); 1770 int pmp = sata_srst_pmp(link); 1771 int rc; 1772 u32 irq_sts; 1773 1774 DPRINTK("ENTER\n"); 1775 1776 rc = ahci_do_softreset(link, class, pmp, deadline, 1777 ahci_sb600_check_ready); 1778 1779 /* 1780 * Soft reset fails on some ATI chips with IPMS set when PMP 1781 * is enabled but SATA HDD/ODD is connected to SATA port, 1782 * do soft reset again to port 0. 1783 */ 1784 if (rc == -EIO) { 1785 irq_sts = readl(port_mmio + PORT_IRQ_STAT); 1786 if (irq_sts & PORT_IRQ_BAD_PMP) { 1787 ata_link_printk(link, KERN_WARNING, 1788 "applying SB600 PMP SRST workaround " 1789 "and retrying\n"); 1790 rc = ahci_do_softreset(link, class, 0, deadline, 1791 ahci_check_ready); 1792 } 1793 } 1794 1795 return rc; 1796 } 1797 1798 static int ahci_hardreset(struct ata_link *link, unsigned int *class, 1799 unsigned long deadline) 1800 { 1801 const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context); 1802 struct ata_port *ap = link->ap; 1803 struct ahci_port_priv *pp = ap->private_data; 1804 u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG; 1805 struct ata_taskfile tf; 1806 bool online; 1807 int rc; 1808 1809 DPRINTK("ENTER\n"); 1810 1811 ahci_stop_engine(ap); 1812 1813 /* clear D2H reception area to properly wait for D2H FIS */ 1814 ata_tf_init(link->device, &tf); 1815 tf.command = 0x80; 1816 ata_tf_to_fis(&tf, 0, 0, d2h_fis); 1817 1818 rc = sata_link_hardreset(link, timing, deadline, &online, 1819 ahci_check_ready); 1820 1821 ahci_start_engine(ap); 1822 1823 if (online) 1824 *class = ahci_dev_classify(ap); 1825 1826 DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class); 1827 return rc; 1828 } 1829 1830 static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class, 1831 unsigned long deadline) 1832 { 1833 struct ata_port *ap = link->ap; 1834 bool online; 1835 int rc; 1836 1837 DPRINTK("ENTER\n"); 1838 1839 ahci_stop_engine(ap); 1840 1841 rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context), 1842 deadline, &online, NULL); 1843 1844 ahci_start_engine(ap); 1845 1846 DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class); 1847 1848 /* vt8251 doesn't clear BSY on signature FIS reception, 1849 * request follow-up softreset. 1850 */ 1851 return online ? -EAGAIN : rc; 1852 } 1853 1854 static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class, 1855 unsigned long deadline) 1856 { 1857 struct ata_port *ap = link->ap; 1858 struct ahci_port_priv *pp = ap->private_data; 1859 u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG; 1860 struct ata_taskfile tf; 1861 bool online; 1862 int rc; 1863 1864 ahci_stop_engine(ap); 1865 1866 /* clear D2H reception area to properly wait for D2H FIS */ 1867 ata_tf_init(link->device, &tf); 1868 tf.command = 0x80; 1869 ata_tf_to_fis(&tf, 0, 0, d2h_fis); 1870 1871 rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context), 1872 deadline, &online, NULL); 1873 1874 ahci_start_engine(ap); 1875 1876 /* The pseudo configuration device on SIMG4726 attached to 1877 * ASUS P5W-DH Deluxe doesn't send signature FIS after 1878 * hardreset if no device is attached to the first downstream 1879 * port && the pseudo device locks up on SRST w/ PMP==0. To 1880 * work around this, wait for !BSY only briefly. If BSY isn't 1881 * cleared, perform CLO and proceed to IDENTIFY (achieved by 1882 * ATA_LFLAG_NO_SRST and ATA_LFLAG_ASSUME_ATA). 1883 * 1884 * Wait for two seconds. Devices attached to downstream port 1885 * which can't process the following IDENTIFY after this will 1886 * have to be reset again. For most cases, this should 1887 * suffice while making probing snappish enough. 1888 */ 1889 if (online) { 1890 rc = ata_wait_after_reset(link, jiffies + 2 * HZ, 1891 ahci_check_ready); 1892 if (rc) 1893 ahci_kick_engine(ap, 0); 1894 } 1895 return rc; 1896 } 1897 1898 static void ahci_postreset(struct ata_link *link, unsigned int *class) 1899 { 1900 struct ata_port *ap = link->ap; 1901 void __iomem *port_mmio = ahci_port_base(ap); 1902 u32 new_tmp, tmp; 1903 1904 ata_std_postreset(link, class); 1905 1906 /* Make sure port's ATAPI bit is set appropriately */ 1907 new_tmp = tmp = readl(port_mmio + PORT_CMD); 1908 if (*class == ATA_DEV_ATAPI) 1909 new_tmp |= PORT_CMD_ATAPI; 1910 else 1911 new_tmp &= ~PORT_CMD_ATAPI; 1912 if (new_tmp != tmp) { 1913 writel(new_tmp, port_mmio + PORT_CMD); 1914 readl(port_mmio + PORT_CMD); /* flush */ 1915 } 1916 } 1917 1918 static unsigned int ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl) 1919 { 1920 struct scatterlist *sg; 1921 struct ahci_sg *ahci_sg = cmd_tbl + AHCI_CMD_TBL_HDR_SZ; 1922 unsigned int si; 1923 1924 VPRINTK("ENTER\n"); 1925 1926 /* 1927 * Next, the S/G list. 1928 */ 1929 for_each_sg(qc->sg, sg, qc->n_elem, si) { 1930 dma_addr_t addr = sg_dma_address(sg); 1931 u32 sg_len = sg_dma_len(sg); 1932 1933 ahci_sg[si].addr = cpu_to_le32(addr & 0xffffffff); 1934 ahci_sg[si].addr_hi = cpu_to_le32((addr >> 16) >> 16); 1935 ahci_sg[si].flags_size = cpu_to_le32(sg_len - 1); 1936 } 1937 1938 return si; 1939 } 1940 1941 static void ahci_qc_prep(struct ata_queued_cmd *qc) 1942 { 1943 struct ata_port *ap = qc->ap; 1944 struct ahci_port_priv *pp = ap->private_data; 1945 int is_atapi = ata_is_atapi(qc->tf.protocol); 1946 void *cmd_tbl; 1947 u32 opts; 1948 const u32 cmd_fis_len = 5; /* five dwords */ 1949 unsigned int n_elem; 1950 1951 /* 1952 * Fill in command table information. First, the header, 1953 * a SATA Register - Host to Device command FIS. 1954 */ 1955 cmd_tbl = pp->cmd_tbl + qc->tag * AHCI_CMD_TBL_SZ; 1956 1957 ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, cmd_tbl); 1958 if (is_atapi) { 1959 memset(cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32); 1960 memcpy(cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, qc->dev->cdb_len); 1961 } 1962 1963 n_elem = 0; 1964 if (qc->flags & ATA_QCFLAG_DMAMAP) 1965 n_elem = ahci_fill_sg(qc, cmd_tbl); 1966 1967 /* 1968 * Fill in command slot information. 1969 */ 1970 opts = cmd_fis_len | n_elem << 16 | (qc->dev->link->pmp << 12); 1971 if (qc->tf.flags & ATA_TFLAG_WRITE) 1972 opts |= AHCI_CMD_WRITE; 1973 if (is_atapi) 1974 opts |= AHCI_CMD_ATAPI | AHCI_CMD_PREFETCH; 1975 1976 ahci_fill_cmd_slot(pp, qc->tag, opts); 1977 } 1978 1979 static void ahci_error_intr(struct ata_port *ap, u32 irq_stat) 1980 { 1981 struct ahci_host_priv *hpriv = ap->host->private_data; 1982 struct ahci_port_priv *pp = ap->private_data; 1983 struct ata_eh_info *host_ehi = &ap->link.eh_info; 1984 struct ata_link *link = NULL; 1985 struct ata_queued_cmd *active_qc; 1986 struct ata_eh_info *active_ehi; 1987 u32 serror; 1988 1989 /* determine active link */ 1990 ata_for_each_link(link, ap, EDGE) 1991 if (ata_link_active(link)) 1992 break; 1993 if (!link) 1994 link = &ap->link; 1995 1996 active_qc = ata_qc_from_tag(ap, link->active_tag); 1997 active_ehi = &link->eh_info; 1998 1999 /* record irq stat */ 2000 ata_ehi_clear_desc(host_ehi); 2001 ata_ehi_push_desc(host_ehi, "irq_stat 0x%08x", irq_stat); 2002 2003 /* AHCI needs SError cleared; otherwise, it might lock up */ 2004 ahci_scr_read(&ap->link, SCR_ERROR, &serror); 2005 ahci_scr_write(&ap->link, SCR_ERROR, serror); 2006 host_ehi->serror |= serror; 2007 2008 /* some controllers set IRQ_IF_ERR on device errors, ignore it */ 2009 if (hpriv->flags & AHCI_HFLAG_IGN_IRQ_IF_ERR) 2010 irq_stat &= ~PORT_IRQ_IF_ERR; 2011 2012 if (irq_stat & PORT_IRQ_TF_ERR) { 2013 /* If qc is active, charge it; otherwise, the active 2014 * link. There's no active qc on NCQ errors. It will 2015 * be determined by EH by reading log page 10h. 2016 */ 2017 if (active_qc) 2018 active_qc->err_mask |= AC_ERR_DEV; 2019 else 2020 active_ehi->err_mask |= AC_ERR_DEV; 2021 2022 if (hpriv->flags & AHCI_HFLAG_IGN_SERR_INTERNAL) 2023 host_ehi->serror &= ~SERR_INTERNAL; 2024 } 2025 2026 if (irq_stat & PORT_IRQ_UNK_FIS) { 2027 u32 *unk = (u32 *)(pp->rx_fis + RX_FIS_UNK); 2028 2029 active_ehi->err_mask |= AC_ERR_HSM; 2030 active_ehi->action |= ATA_EH_RESET; 2031 ata_ehi_push_desc(active_ehi, 2032 "unknown FIS %08x %08x %08x %08x" , 2033 unk[0], unk[1], unk[2], unk[3]); 2034 } 2035 2036 if (sata_pmp_attached(ap) && (irq_stat & PORT_IRQ_BAD_PMP)) { 2037 active_ehi->err_mask |= AC_ERR_HSM; 2038 active_ehi->action |= ATA_EH_RESET; 2039 ata_ehi_push_desc(active_ehi, "incorrect PMP"); 2040 } 2041 2042 if (irq_stat & (PORT_IRQ_HBUS_ERR | PORT_IRQ_HBUS_DATA_ERR)) { 2043 host_ehi->err_mask |= AC_ERR_HOST_BUS; 2044 host_ehi->action |= ATA_EH_RESET; 2045 ata_ehi_push_desc(host_ehi, "host bus error"); 2046 } 2047 2048 if (irq_stat & PORT_IRQ_IF_ERR) { 2049 host_ehi->err_mask |= AC_ERR_ATA_BUS; 2050 host_ehi->action |= ATA_EH_RESET; 2051 ata_ehi_push_desc(host_ehi, "interface fatal error"); 2052 } 2053 2054 if (irq_stat & (PORT_IRQ_CONNECT | PORT_IRQ_PHYRDY)) { 2055 ata_ehi_hotplugged(host_ehi); 2056 ata_ehi_push_desc(host_ehi, "%s", 2057 irq_stat & PORT_IRQ_CONNECT ? 2058 "connection status changed" : "PHY RDY changed"); 2059 } 2060 2061 /* okay, let's hand over to EH */ 2062 2063 if (irq_stat & PORT_IRQ_FREEZE) 2064 ata_port_freeze(ap); 2065 else 2066 ata_port_abort(ap); 2067 } 2068 2069 static void ahci_port_intr(struct ata_port *ap) 2070 { 2071 void __iomem *port_mmio = ahci_port_base(ap); 2072 struct ata_eh_info *ehi = &ap->link.eh_info; 2073 struct ahci_port_priv *pp = ap->private_data; 2074 struct ahci_host_priv *hpriv = ap->host->private_data; 2075 int resetting = !!(ap->pflags & ATA_PFLAG_RESETTING); 2076 u32 status, qc_active; 2077 int rc; 2078 2079 status = readl(port_mmio + PORT_IRQ_STAT); 2080 writel(status, port_mmio + PORT_IRQ_STAT); 2081 2082 /* ignore BAD_PMP while resetting */ 2083 if (unlikely(resetting)) 2084 status &= ~PORT_IRQ_BAD_PMP; 2085 2086 /* If we are getting PhyRdy, this is 2087 * just a power state change, we should 2088 * clear out this, plus the PhyRdy/Comm 2089 * Wake bits from Serror 2090 */ 2091 if ((hpriv->flags & AHCI_HFLAG_NO_HOTPLUG) && 2092 (status & PORT_IRQ_PHYRDY)) { 2093 status &= ~PORT_IRQ_PHYRDY; 2094 ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18))); 2095 } 2096 2097 if (unlikely(status & PORT_IRQ_ERROR)) { 2098 ahci_error_intr(ap, status); 2099 return; 2100 } 2101 2102 if (status & PORT_IRQ_SDB_FIS) { 2103 /* If SNotification is available, leave notification 2104 * handling to sata_async_notification(). If not, 2105 * emulate it by snooping SDB FIS RX area. 2106 * 2107 * Snooping FIS RX area is probably cheaper than 2108 * poking SNotification but some constrollers which 2109 * implement SNotification, ICH9 for example, don't 2110 * store AN SDB FIS into receive area. 2111 */ 2112 if (hpriv->cap & HOST_CAP_SNTF) 2113 sata_async_notification(ap); 2114 else { 2115 /* If the 'N' bit in word 0 of the FIS is set, 2116 * we just received asynchronous notification. 2117 * Tell libata about it. 2118 */ 2119 const __le32 *f = pp->rx_fis + RX_FIS_SDB; 2120 u32 f0 = le32_to_cpu(f[0]); 2121 2122 if (f0 & (1 << 15)) 2123 sata_async_notification(ap); 2124 } 2125 } 2126 2127 /* pp->active_link is valid iff any command is in flight */ 2128 if (ap->qc_active && pp->active_link->sactive) 2129 qc_active = readl(port_mmio + PORT_SCR_ACT); 2130 else 2131 qc_active = readl(port_mmio + PORT_CMD_ISSUE); 2132 2133 rc = ata_qc_complete_multiple(ap, qc_active); 2134 2135 /* while resetting, invalid completions are expected */ 2136 if (unlikely(rc < 0 && !resetting)) { 2137 ehi->err_mask |= AC_ERR_HSM; 2138 ehi->action |= ATA_EH_RESET; 2139 ata_port_freeze(ap); 2140 } 2141 } 2142 2143 static irqreturn_t ahci_interrupt(int irq, void *dev_instance) 2144 { 2145 struct ata_host *host = dev_instance; 2146 struct ahci_host_priv *hpriv; 2147 unsigned int i, handled = 0; 2148 void __iomem *mmio; 2149 u32 irq_stat, irq_masked; 2150 2151 VPRINTK("ENTER\n"); 2152 2153 hpriv = host->private_data; 2154 mmio = host->iomap[AHCI_PCI_BAR]; 2155 2156 /* sigh. 0xffffffff is a valid return from h/w */ 2157 irq_stat = readl(mmio + HOST_IRQ_STAT); 2158 if (!irq_stat) 2159 return IRQ_NONE; 2160 2161 irq_masked = irq_stat & hpriv->port_map; 2162 2163 spin_lock(&host->lock); 2164 2165 for (i = 0; i < host->n_ports; i++) { 2166 struct ata_port *ap; 2167 2168 if (!(irq_masked & (1 << i))) 2169 continue; 2170 2171 ap = host->ports[i]; 2172 if (ap) { 2173 ahci_port_intr(ap); 2174 VPRINTK("port %u\n", i); 2175 } else { 2176 VPRINTK("port %u (no irq)\n", i); 2177 if (ata_ratelimit()) 2178 dev_printk(KERN_WARNING, host->dev, 2179 "interrupt on disabled port %u\n", i); 2180 } 2181 2182 handled = 1; 2183 } 2184 2185 /* HOST_IRQ_STAT behaves as level triggered latch meaning that 2186 * it should be cleared after all the port events are cleared; 2187 * otherwise, it will raise a spurious interrupt after each 2188 * valid one. Please read section 10.6.2 of ahci 1.1 for more 2189 * information. 2190 * 2191 * Also, use the unmasked value to clear interrupt as spurious 2192 * pending event on a dummy port might cause screaming IRQ. 2193 */ 2194 writel(irq_stat, mmio + HOST_IRQ_STAT); 2195 2196 spin_unlock(&host->lock); 2197 2198 VPRINTK("EXIT\n"); 2199 2200 return IRQ_RETVAL(handled); 2201 } 2202 2203 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc) 2204 { 2205 struct ata_port *ap = qc->ap; 2206 void __iomem *port_mmio = ahci_port_base(ap); 2207 struct ahci_port_priv *pp = ap->private_data; 2208 2209 /* Keep track of the currently active link. It will be used 2210 * in completion path to determine whether NCQ phase is in 2211 * progress. 2212 */ 2213 pp->active_link = qc->dev->link; 2214 2215 if (qc->tf.protocol == ATA_PROT_NCQ) 2216 writel(1 << qc->tag, port_mmio + PORT_SCR_ACT); 2217 writel(1 << qc->tag, port_mmio + PORT_CMD_ISSUE); 2218 2219 ahci_sw_activity(qc->dev->link); 2220 2221 return 0; 2222 } 2223 2224 static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc) 2225 { 2226 struct ahci_port_priv *pp = qc->ap->private_data; 2227 u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG; 2228 2229 ata_tf_from_fis(d2h_fis, &qc->result_tf); 2230 return true; 2231 } 2232 2233 static void ahci_freeze(struct ata_port *ap) 2234 { 2235 void __iomem *port_mmio = ahci_port_base(ap); 2236 2237 /* turn IRQ off */ 2238 writel(0, port_mmio + PORT_IRQ_MASK); 2239 } 2240 2241 static void ahci_thaw(struct ata_port *ap) 2242 { 2243 void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR]; 2244 void __iomem *port_mmio = ahci_port_base(ap); 2245 u32 tmp; 2246 struct ahci_port_priv *pp = ap->private_data; 2247 2248 /* clear IRQ */ 2249 tmp = readl(port_mmio + PORT_IRQ_STAT); 2250 writel(tmp, port_mmio + PORT_IRQ_STAT); 2251 writel(1 << ap->port_no, mmio + HOST_IRQ_STAT); 2252 2253 /* turn IRQ back on */ 2254 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK); 2255 } 2256 2257 static void ahci_error_handler(struct ata_port *ap) 2258 { 2259 if (!(ap->pflags & ATA_PFLAG_FROZEN)) { 2260 /* restart engine */ 2261 ahci_stop_engine(ap); 2262 ahci_start_engine(ap); 2263 } 2264 2265 sata_pmp_error_handler(ap); 2266 } 2267 2268 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc) 2269 { 2270 struct ata_port *ap = qc->ap; 2271 2272 /* make DMA engine forget about the failed command */ 2273 if (qc->flags & ATA_QCFLAG_FAILED) 2274 ahci_kick_engine(ap, 1); 2275 } 2276 2277 static void ahci_pmp_attach(struct ata_port *ap) 2278 { 2279 void __iomem *port_mmio = ahci_port_base(ap); 2280 struct ahci_port_priv *pp = ap->private_data; 2281 u32 cmd; 2282 2283 cmd = readl(port_mmio + PORT_CMD); 2284 cmd |= PORT_CMD_PMP; 2285 writel(cmd, port_mmio + PORT_CMD); 2286 2287 pp->intr_mask |= PORT_IRQ_BAD_PMP; 2288 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK); 2289 } 2290 2291 static void ahci_pmp_detach(struct ata_port *ap) 2292 { 2293 void __iomem *port_mmio = ahci_port_base(ap); 2294 struct ahci_port_priv *pp = ap->private_data; 2295 u32 cmd; 2296 2297 cmd = readl(port_mmio + PORT_CMD); 2298 cmd &= ~PORT_CMD_PMP; 2299 writel(cmd, port_mmio + PORT_CMD); 2300 2301 pp->intr_mask &= ~PORT_IRQ_BAD_PMP; 2302 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK); 2303 } 2304 2305 static int ahci_port_resume(struct ata_port *ap) 2306 { 2307 ahci_power_up(ap); 2308 ahci_start_port(ap); 2309 2310 if (sata_pmp_attached(ap)) 2311 ahci_pmp_attach(ap); 2312 else 2313 ahci_pmp_detach(ap); 2314 2315 return 0; 2316 } 2317 2318 #ifdef CONFIG_PM 2319 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg) 2320 { 2321 const char *emsg = NULL; 2322 int rc; 2323 2324 rc = ahci_deinit_port(ap, &emsg); 2325 if (rc == 0) 2326 ahci_power_down(ap); 2327 else { 2328 ata_port_printk(ap, KERN_ERR, "%s (%d)\n", emsg, rc); 2329 ahci_start_port(ap); 2330 } 2331 2332 return rc; 2333 } 2334 2335 static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg) 2336 { 2337 struct ata_host *host = dev_get_drvdata(&pdev->dev); 2338 struct ahci_host_priv *hpriv = host->private_data; 2339 void __iomem *mmio = host->iomap[AHCI_PCI_BAR]; 2340 u32 ctl; 2341 2342 if (mesg.event & PM_EVENT_SUSPEND && 2343 hpriv->flags & AHCI_HFLAG_NO_SUSPEND) { 2344 dev_printk(KERN_ERR, &pdev->dev, 2345 "BIOS update required for suspend/resume\n"); 2346 return -EIO; 2347 } 2348 2349 if (mesg.event & PM_EVENT_SLEEP) { 2350 /* AHCI spec rev1.1 section 8.3.3: 2351 * Software must disable interrupts prior to requesting a 2352 * transition of the HBA to D3 state. 2353 */ 2354 ctl = readl(mmio + HOST_CTL); 2355 ctl &= ~HOST_IRQ_EN; 2356 writel(ctl, mmio + HOST_CTL); 2357 readl(mmio + HOST_CTL); /* flush */ 2358 } 2359 2360 return ata_pci_device_suspend(pdev, mesg); 2361 } 2362 2363 static int ahci_pci_device_resume(struct pci_dev *pdev) 2364 { 2365 struct ata_host *host = dev_get_drvdata(&pdev->dev); 2366 int rc; 2367 2368 rc = ata_pci_device_do_resume(pdev); 2369 if (rc) 2370 return rc; 2371 2372 if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) { 2373 rc = ahci_reset_controller(host); 2374 if (rc) 2375 return rc; 2376 2377 ahci_init_controller(host); 2378 } 2379 2380 ata_host_resume(host); 2381 2382 return 0; 2383 } 2384 #endif 2385 2386 static int ahci_port_start(struct ata_port *ap) 2387 { 2388 struct device *dev = ap->host->dev; 2389 struct ahci_port_priv *pp; 2390 void *mem; 2391 dma_addr_t mem_dma; 2392 2393 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL); 2394 if (!pp) 2395 return -ENOMEM; 2396 2397 mem = dmam_alloc_coherent(dev, AHCI_PORT_PRIV_DMA_SZ, &mem_dma, 2398 GFP_KERNEL); 2399 if (!mem) 2400 return -ENOMEM; 2401 memset(mem, 0, AHCI_PORT_PRIV_DMA_SZ); 2402 2403 /* 2404 * First item in chunk of DMA memory: 32-slot command table, 2405 * 32 bytes each in size 2406 */ 2407 pp->cmd_slot = mem; 2408 pp->cmd_slot_dma = mem_dma; 2409 2410 mem += AHCI_CMD_SLOT_SZ; 2411 mem_dma += AHCI_CMD_SLOT_SZ; 2412 2413 /* 2414 * Second item: Received-FIS area 2415 */ 2416 pp->rx_fis = mem; 2417 pp->rx_fis_dma = mem_dma; 2418 2419 mem += AHCI_RX_FIS_SZ; 2420 mem_dma += AHCI_RX_FIS_SZ; 2421 2422 /* 2423 * Third item: data area for storing a single command 2424 * and its scatter-gather table 2425 */ 2426 pp->cmd_tbl = mem; 2427 pp->cmd_tbl_dma = mem_dma; 2428 2429 /* 2430 * Save off initial list of interrupts to be enabled. 2431 * This could be changed later 2432 */ 2433 pp->intr_mask = DEF_PORT_IRQ; 2434 2435 ap->private_data = pp; 2436 2437 /* engage engines, captain */ 2438 return ahci_port_resume(ap); 2439 } 2440 2441 static void ahci_port_stop(struct ata_port *ap) 2442 { 2443 const char *emsg = NULL; 2444 int rc; 2445 2446 /* de-initialize port */ 2447 rc = ahci_deinit_port(ap, &emsg); 2448 if (rc) 2449 ata_port_printk(ap, KERN_WARNING, "%s (%d)\n", emsg, rc); 2450 } 2451 2452 static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac) 2453 { 2454 int rc; 2455 2456 if (using_dac && 2457 !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { 2458 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); 2459 if (rc) { 2460 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 2461 if (rc) { 2462 dev_printk(KERN_ERR, &pdev->dev, 2463 "64-bit DMA enable failed\n"); 2464 return rc; 2465 } 2466 } 2467 } else { 2468 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 2469 if (rc) { 2470 dev_printk(KERN_ERR, &pdev->dev, 2471 "32-bit DMA enable failed\n"); 2472 return rc; 2473 } 2474 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 2475 if (rc) { 2476 dev_printk(KERN_ERR, &pdev->dev, 2477 "32-bit consistent DMA enable failed\n"); 2478 return rc; 2479 } 2480 } 2481 return 0; 2482 } 2483 2484 static void ahci_print_info(struct ata_host *host) 2485 { 2486 struct ahci_host_priv *hpriv = host->private_data; 2487 struct pci_dev *pdev = to_pci_dev(host->dev); 2488 void __iomem *mmio = host->iomap[AHCI_PCI_BAR]; 2489 u32 vers, cap, impl, speed; 2490 const char *speed_s; 2491 u16 cc; 2492 const char *scc_s; 2493 2494 vers = readl(mmio + HOST_VERSION); 2495 cap = hpriv->cap; 2496 impl = hpriv->port_map; 2497 2498 speed = (cap >> 20) & 0xf; 2499 if (speed == 1) 2500 speed_s = "1.5"; 2501 else if (speed == 2) 2502 speed_s = "3"; 2503 else if (speed == 3) 2504 speed_s = "6"; 2505 else 2506 speed_s = "?"; 2507 2508 pci_read_config_word(pdev, 0x0a, &cc); 2509 if (cc == PCI_CLASS_STORAGE_IDE) 2510 scc_s = "IDE"; 2511 else if (cc == PCI_CLASS_STORAGE_SATA) 2512 scc_s = "SATA"; 2513 else if (cc == PCI_CLASS_STORAGE_RAID) 2514 scc_s = "RAID"; 2515 else 2516 scc_s = "unknown"; 2517 2518 dev_printk(KERN_INFO, &pdev->dev, 2519 "AHCI %02x%02x.%02x%02x " 2520 "%u slots %u ports %s Gbps 0x%x impl %s mode\n" 2521 , 2522 2523 (vers >> 24) & 0xff, 2524 (vers >> 16) & 0xff, 2525 (vers >> 8) & 0xff, 2526 vers & 0xff, 2527 2528 ((cap >> 8) & 0x1f) + 1, 2529 (cap & 0x1f) + 1, 2530 speed_s, 2531 impl, 2532 scc_s); 2533 2534 dev_printk(KERN_INFO, &pdev->dev, 2535 "flags: " 2536 "%s%s%s%s%s%s%s" 2537 "%s%s%s%s%s%s%s" 2538 "%s\n" 2539 , 2540 2541 cap & (1 << 31) ? "64bit " : "", 2542 cap & (1 << 30) ? "ncq " : "", 2543 cap & (1 << 29) ? "sntf " : "", 2544 cap & (1 << 28) ? "ilck " : "", 2545 cap & (1 << 27) ? "stag " : "", 2546 cap & (1 << 26) ? "pm " : "", 2547 cap & (1 << 25) ? "led " : "", 2548 2549 cap & (1 << 24) ? "clo " : "", 2550 cap & (1 << 19) ? "nz " : "", 2551 cap & (1 << 18) ? "only " : "", 2552 cap & (1 << 17) ? "pmp " : "", 2553 cap & (1 << 15) ? "pio " : "", 2554 cap & (1 << 14) ? "slum " : "", 2555 cap & (1 << 13) ? "part " : "", 2556 cap & (1 << 6) ? "ems ": "" 2557 ); 2558 } 2559 2560 /* On ASUS P5W DH Deluxe, the second port of PCI device 00:1f.2 is 2561 * hardwired to on-board SIMG 4726. The chipset is ICH8 and doesn't 2562 * support PMP and the 4726 either directly exports the device 2563 * attached to the first downstream port or acts as a hardware storage 2564 * controller and emulate a single ATA device (can be RAID 0/1 or some 2565 * other configuration). 2566 * 2567 * When there's no device attached to the first downstream port of the 2568 * 4726, "Config Disk" appears, which is a pseudo ATA device to 2569 * configure the 4726. However, ATA emulation of the device is very 2570 * lame. It doesn't send signature D2H Reg FIS after the initial 2571 * hardreset, pukes on SRST w/ PMP==0 and has bunch of other issues. 2572 * 2573 * The following function works around the problem by always using 2574 * hardreset on the port and not depending on receiving signature FIS 2575 * afterward. If signature FIS isn't received soon, ATA class is 2576 * assumed without follow-up softreset. 2577 */ 2578 static void ahci_p5wdh_workaround(struct ata_host *host) 2579 { 2580 static struct dmi_system_id sysids[] = { 2581 { 2582 .ident = "P5W DH Deluxe", 2583 .matches = { 2584 DMI_MATCH(DMI_SYS_VENDOR, 2585 "ASUSTEK COMPUTER INC"), 2586 DMI_MATCH(DMI_PRODUCT_NAME, "P5W DH Deluxe"), 2587 }, 2588 }, 2589 { } 2590 }; 2591 struct pci_dev *pdev = to_pci_dev(host->dev); 2592 2593 if (pdev->bus->number == 0 && pdev->devfn == PCI_DEVFN(0x1f, 2) && 2594 dmi_check_system(sysids)) { 2595 struct ata_port *ap = host->ports[1]; 2596 2597 dev_printk(KERN_INFO, &pdev->dev, "enabling ASUS P5W DH " 2598 "Deluxe on-board SIMG4726 workaround\n"); 2599 2600 ap->ops = &ahci_p5wdh_ops; 2601 ap->link.flags |= ATA_LFLAG_NO_SRST | ATA_LFLAG_ASSUME_ATA; 2602 } 2603 } 2604 2605 /* 2606 * SB600 ahci controller on ASUS M2A-VM can't do 64bit DMA with older 2607 * BIOS. The oldest version known to be broken is 0901 and working is 2608 * 1501 which was released on 2007-10-26. Force 32bit DMA on anything 2609 * older than 1501. Please read bko#9412 for more info. 2610 */ 2611 static bool ahci_asus_m2a_vm_32bit_only(struct pci_dev *pdev) 2612 { 2613 static const struct dmi_system_id sysids[] = { 2614 { 2615 .ident = "ASUS M2A-VM", 2616 .matches = { 2617 DMI_MATCH(DMI_BOARD_VENDOR, 2618 "ASUSTeK Computer INC."), 2619 DMI_MATCH(DMI_BOARD_NAME, "M2A-VM"), 2620 }, 2621 }, 2622 { } 2623 }; 2624 const char *cutoff_mmdd = "10/26"; 2625 const char *date; 2626 int year; 2627 2628 if (pdev->bus->number != 0 || pdev->devfn != PCI_DEVFN(0x12, 0) || 2629 !dmi_check_system(sysids)) 2630 return false; 2631 2632 /* 2633 * Argh.... both version and date are free form strings. 2634 * Let's hope they're using the same date format across 2635 * different versions. 2636 */ 2637 date = dmi_get_system_info(DMI_BIOS_DATE); 2638 year = dmi_get_year(DMI_BIOS_DATE); 2639 if (date && strlen(date) >= 10 && date[2] == '/' && date[5] == '/' && 2640 (year > 2007 || 2641 (year == 2007 && strncmp(date, cutoff_mmdd, 5) >= 0))) 2642 return false; 2643 2644 dev_printk(KERN_WARNING, &pdev->dev, "ASUS M2A-VM: BIOS too old, " 2645 "forcing 32bit DMA, update BIOS\n"); 2646 2647 return true; 2648 } 2649 2650 static bool ahci_broken_system_poweroff(struct pci_dev *pdev) 2651 { 2652 static const struct dmi_system_id broken_systems[] = { 2653 { 2654 .ident = "HP Compaq nx6310", 2655 .matches = { 2656 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 2657 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6310"), 2658 }, 2659 /* PCI slot number of the controller */ 2660 .driver_data = (void *)0x1FUL, 2661 }, 2662 { 2663 .ident = "HP Compaq 6720s", 2664 .matches = { 2665 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 2666 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6720s"), 2667 }, 2668 /* PCI slot number of the controller */ 2669 .driver_data = (void *)0x1FUL, 2670 }, 2671 2672 { } /* terminate list */ 2673 }; 2674 const struct dmi_system_id *dmi = dmi_first_match(broken_systems); 2675 2676 if (dmi) { 2677 unsigned long slot = (unsigned long)dmi->driver_data; 2678 /* apply the quirk only to on-board controllers */ 2679 return slot == PCI_SLOT(pdev->devfn); 2680 } 2681 2682 return false; 2683 } 2684 2685 static bool ahci_broken_suspend(struct pci_dev *pdev) 2686 { 2687 static const struct dmi_system_id sysids[] = { 2688 /* 2689 * On HP dv[4-6] and HDX18 with earlier BIOSen, link 2690 * to the harddisk doesn't become online after 2691 * resuming from STR. Warn and fail suspend. 2692 */ 2693 { 2694 .ident = "dv4", 2695 .matches = { 2696 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 2697 DMI_MATCH(DMI_PRODUCT_NAME, 2698 "HP Pavilion dv4 Notebook PC"), 2699 }, 2700 .driver_data = "F.30", /* cutoff BIOS version */ 2701 }, 2702 { 2703 .ident = "dv5", 2704 .matches = { 2705 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 2706 DMI_MATCH(DMI_PRODUCT_NAME, 2707 "HP Pavilion dv5 Notebook PC"), 2708 }, 2709 .driver_data = "F.16", /* cutoff BIOS version */ 2710 }, 2711 { 2712 .ident = "dv6", 2713 .matches = { 2714 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 2715 DMI_MATCH(DMI_PRODUCT_NAME, 2716 "HP Pavilion dv6 Notebook PC"), 2717 }, 2718 .driver_data = "F.21", /* cutoff BIOS version */ 2719 }, 2720 { 2721 .ident = "HDX18", 2722 .matches = { 2723 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 2724 DMI_MATCH(DMI_PRODUCT_NAME, 2725 "HP HDX18 Notebook PC"), 2726 }, 2727 .driver_data = "F.23", /* cutoff BIOS version */ 2728 }, 2729 { } /* terminate list */ 2730 }; 2731 const struct dmi_system_id *dmi = dmi_first_match(sysids); 2732 const char *ver; 2733 2734 if (!dmi || pdev->bus->number || pdev->devfn != PCI_DEVFN(0x1f, 2)) 2735 return false; 2736 2737 ver = dmi_get_system_info(DMI_BIOS_VERSION); 2738 2739 return !ver || strcmp(ver, dmi->driver_data) < 0; 2740 } 2741 2742 static bool ahci_broken_online(struct pci_dev *pdev) 2743 { 2744 #define ENCODE_BUSDEVFN(bus, slot, func) \ 2745 (void *)(unsigned long)(((bus) << 8) | PCI_DEVFN((slot), (func))) 2746 static const struct dmi_system_id sysids[] = { 2747 /* 2748 * There are several gigabyte boards which use 2749 * SIMG5723s configured as hardware RAID. Certain 2750 * 5723 firmware revisions shipped there keep the link 2751 * online but fail to answer properly to SRST or 2752 * IDENTIFY when no device is attached downstream 2753 * causing libata to retry quite a few times leading 2754 * to excessive detection delay. 2755 * 2756 * As these firmwares respond to the second reset try 2757 * with invalid device signature, considering unknown 2758 * sig as offline works around the problem acceptably. 2759 */ 2760 { 2761 .ident = "EP45-DQ6", 2762 .matches = { 2763 DMI_MATCH(DMI_BOARD_VENDOR, 2764 "Gigabyte Technology Co., Ltd."), 2765 DMI_MATCH(DMI_BOARD_NAME, "EP45-DQ6"), 2766 }, 2767 .driver_data = ENCODE_BUSDEVFN(0x0a, 0x00, 0), 2768 }, 2769 { 2770 .ident = "EP45-DS5", 2771 .matches = { 2772 DMI_MATCH(DMI_BOARD_VENDOR, 2773 "Gigabyte Technology Co., Ltd."), 2774 DMI_MATCH(DMI_BOARD_NAME, "EP45-DS5"), 2775 }, 2776 .driver_data = ENCODE_BUSDEVFN(0x03, 0x00, 0), 2777 }, 2778 { } /* terminate list */ 2779 }; 2780 #undef ENCODE_BUSDEVFN 2781 const struct dmi_system_id *dmi = dmi_first_match(sysids); 2782 unsigned int val; 2783 2784 if (!dmi) 2785 return false; 2786 2787 val = (unsigned long)dmi->driver_data; 2788 2789 return pdev->bus->number == (val >> 8) && pdev->devfn == (val & 0xff); 2790 } 2791 2792 static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 2793 { 2794 static int printed_version; 2795 unsigned int board_id = ent->driver_data; 2796 struct ata_port_info pi = ahci_port_info[board_id]; 2797 const struct ata_port_info *ppi[] = { &pi, NULL }; 2798 struct device *dev = &pdev->dev; 2799 struct ahci_host_priv *hpriv; 2800 struct ata_host *host; 2801 int n_ports, i, rc; 2802 2803 VPRINTK("ENTER\n"); 2804 2805 WARN_ON(ATA_MAX_QUEUE > AHCI_MAX_CMDS); 2806 2807 if (!printed_version++) 2808 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n"); 2809 2810 /* The AHCI driver can only drive the SATA ports, the PATA driver 2811 can drive them all so if both drivers are selected make sure 2812 AHCI stays out of the way */ 2813 if (pdev->vendor == PCI_VENDOR_ID_MARVELL && !marvell_enable) 2814 return -ENODEV; 2815 2816 /* acquire resources */ 2817 rc = pcim_enable_device(pdev); 2818 if (rc) 2819 return rc; 2820 2821 /* AHCI controllers often implement SFF compatible interface. 2822 * Grab all PCI BARs just in case. 2823 */ 2824 rc = pcim_iomap_regions_request_all(pdev, 1 << AHCI_PCI_BAR, DRV_NAME); 2825 if (rc == -EBUSY) 2826 pcim_pin_device(pdev); 2827 if (rc) 2828 return rc; 2829 2830 if (pdev->vendor == PCI_VENDOR_ID_INTEL && 2831 (pdev->device == 0x2652 || pdev->device == 0x2653)) { 2832 u8 map; 2833 2834 /* ICH6s share the same PCI ID for both piix and ahci 2835 * modes. Enabling ahci mode while MAP indicates 2836 * combined mode is a bad idea. Yield to ata_piix. 2837 */ 2838 pci_read_config_byte(pdev, ICH_MAP, &map); 2839 if (map & 0x3) { 2840 dev_printk(KERN_INFO, &pdev->dev, "controller is in " 2841 "combined mode, can't enable AHCI mode\n"); 2842 return -ENODEV; 2843 } 2844 } 2845 2846 hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL); 2847 if (!hpriv) 2848 return -ENOMEM; 2849 hpriv->flags |= (unsigned long)pi.private_data; 2850 2851 /* MCP65 revision A1 and A2 can't do MSI */ 2852 if (board_id == board_ahci_mcp65 && 2853 (pdev->revision == 0xa1 || pdev->revision == 0xa2)) 2854 hpriv->flags |= AHCI_HFLAG_NO_MSI; 2855 2856 /* SB800 does NOT need the workaround to ignore SERR_INTERNAL */ 2857 if (board_id == board_ahci_sb700 && pdev->revision >= 0x40) 2858 hpriv->flags &= ~AHCI_HFLAG_IGN_SERR_INTERNAL; 2859 2860 /* apply ASUS M2A_VM quirk */ 2861 if (ahci_asus_m2a_vm_32bit_only(pdev)) 2862 hpriv->flags |= AHCI_HFLAG_32BIT_ONLY; 2863 2864 if (!(hpriv->flags & AHCI_HFLAG_NO_MSI)) 2865 pci_enable_msi(pdev); 2866 2867 /* save initial config */ 2868 ahci_save_initial_config(pdev, hpriv); 2869 2870 /* prepare host */ 2871 if (hpriv->cap & HOST_CAP_NCQ) 2872 pi.flags |= ATA_FLAG_NCQ; 2873 2874 if (hpriv->cap & HOST_CAP_PMP) 2875 pi.flags |= ATA_FLAG_PMP; 2876 2877 if (ahci_em_messages && (hpriv->cap & HOST_CAP_EMS)) { 2878 u8 messages; 2879 void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR]; 2880 u32 em_loc = readl(mmio + HOST_EM_LOC); 2881 u32 em_ctl = readl(mmio + HOST_EM_CTL); 2882 2883 messages = (em_ctl & EM_CTRL_MSG_TYPE) >> 16; 2884 2885 /* we only support LED message type right now */ 2886 if ((messages & 0x01) && (ahci_em_messages == 1)) { 2887 /* store em_loc */ 2888 hpriv->em_loc = ((em_loc >> 16) * 4); 2889 pi.flags |= ATA_FLAG_EM; 2890 if (!(em_ctl & EM_CTL_ALHD)) 2891 pi.flags |= ATA_FLAG_SW_ACTIVITY; 2892 } 2893 } 2894 2895 if (ahci_broken_system_poweroff(pdev)) { 2896 pi.flags |= ATA_FLAG_NO_POWEROFF_SPINDOWN; 2897 dev_info(&pdev->dev, 2898 "quirky BIOS, skipping spindown on poweroff\n"); 2899 } 2900 2901 if (ahci_broken_suspend(pdev)) { 2902 hpriv->flags |= AHCI_HFLAG_NO_SUSPEND; 2903 dev_printk(KERN_WARNING, &pdev->dev, 2904 "BIOS update required for suspend/resume\n"); 2905 } 2906 2907 if (ahci_broken_online(pdev)) { 2908 hpriv->flags |= AHCI_HFLAG_SRST_TOUT_IS_OFFLINE; 2909 dev_info(&pdev->dev, 2910 "online status unreliable, applying workaround\n"); 2911 } 2912 2913 /* CAP.NP sometimes indicate the index of the last enabled 2914 * port, at other times, that of the last possible port, so 2915 * determining the maximum port number requires looking at 2916 * both CAP.NP and port_map. 2917 */ 2918 n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map)); 2919 2920 host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports); 2921 if (!host) 2922 return -ENOMEM; 2923 host->iomap = pcim_iomap_table(pdev); 2924 host->private_data = hpriv; 2925 2926 if (!(hpriv->cap & HOST_CAP_SSS) || ahci_ignore_sss) 2927 host->flags |= ATA_HOST_PARALLEL_SCAN; 2928 else 2929 printk(KERN_INFO "ahci: SSS flag set, parallel bus scan disabled\n"); 2930 2931 if (pi.flags & ATA_FLAG_EM) 2932 ahci_reset_em(host); 2933 2934 for (i = 0; i < host->n_ports; i++) { 2935 struct ata_port *ap = host->ports[i]; 2936 2937 ata_port_pbar_desc(ap, AHCI_PCI_BAR, -1, "abar"); 2938 ata_port_pbar_desc(ap, AHCI_PCI_BAR, 2939 0x100 + ap->port_no * 0x80, "port"); 2940 2941 /* set initial link pm policy */ 2942 ap->pm_policy = NOT_AVAILABLE; 2943 2944 /* set enclosure management message type */ 2945 if (ap->flags & ATA_FLAG_EM) 2946 ap->em_message_type = ahci_em_messages; 2947 2948 2949 /* disabled/not-implemented port */ 2950 if (!(hpriv->port_map & (1 << i))) 2951 ap->ops = &ata_dummy_port_ops; 2952 } 2953 2954 /* apply workaround for ASUS P5W DH Deluxe mainboard */ 2955 ahci_p5wdh_workaround(host); 2956 2957 /* initialize adapter */ 2958 rc = ahci_configure_dma_masks(pdev, hpriv->cap & HOST_CAP_64); 2959 if (rc) 2960 return rc; 2961 2962 rc = ahci_reset_controller(host); 2963 if (rc) 2964 return rc; 2965 2966 ahci_init_controller(host); 2967 ahci_print_info(host); 2968 2969 pci_set_master(pdev); 2970 return ata_host_activate(host, pdev->irq, ahci_interrupt, IRQF_SHARED, 2971 &ahci_sht); 2972 } 2973 2974 static int __init ahci_init(void) 2975 { 2976 return pci_register_driver(&ahci_pci_driver); 2977 } 2978 2979 static void __exit ahci_exit(void) 2980 { 2981 pci_unregister_driver(&ahci_pci_driver); 2982 } 2983 2984 2985 MODULE_AUTHOR("Jeff Garzik"); 2986 MODULE_DESCRIPTION("AHCI SATA low-level driver"); 2987 MODULE_LICENSE("GPL"); 2988 MODULE_DEVICE_TABLE(pci, ahci_pci_tbl); 2989 MODULE_VERSION(DRV_VERSION); 2990 2991 module_init(ahci_init); 2992 module_exit(ahci_exit); 2993