1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2013 BayHub Technology Ltd. 4 * 5 * Authors: Peter Guo <peter.guo@bayhubtech.com> 6 * Adam Lee <adam.lee@canonical.com> 7 * Ernest Zhang <ernest.zhang@bayhubtech.com> 8 */ 9 10 #include <linux/pci.h> 11 #include <linux/mmc/host.h> 12 #include <linux/mmc/mmc.h> 13 #include <linux/delay.h> 14 15 #include "sdhci.h" 16 #include "sdhci-pci.h" 17 18 /* 19 * O2Micro device registers 20 */ 21 22 #define O2_SD_MISC_REG5 0x64 23 #define O2_SD_LD0_CTRL 0x68 24 #define O2_SD_DEV_CTRL 0x88 25 #define O2_SD_LOCK_WP 0xD3 26 #define O2_SD_TEST_REG 0xD4 27 #define O2_SD_FUNC_REG0 0xDC 28 #define O2_SD_MULTI_VCC3V 0xEE 29 #define O2_SD_CLKREQ 0xEC 30 #define O2_SD_CAPS 0xE0 31 #define O2_SD_ADMA1 0xE2 32 #define O2_SD_ADMA2 0xE7 33 #define O2_SD_INF_MOD 0xF1 34 #define O2_SD_MISC_CTRL4 0xFC 35 #define O2_SD_TUNING_CTRL 0x300 36 #define O2_SD_PLL_SETTING 0x304 37 #define O2_SD_MISC_SETTING 0x308 38 #define O2_SD_CLK_SETTING 0x328 39 #define O2_SD_CAP_REG2 0x330 40 #define O2_SD_CAP_REG0 0x334 41 #define O2_SD_UHS1_CAP_SETTING 0x33C 42 #define O2_SD_DELAY_CTRL 0x350 43 #define O2_SD_UHS2_L1_CTRL 0x35C 44 #define O2_SD_FUNC_REG3 0x3E0 45 #define O2_SD_FUNC_REG4 0x3E4 46 #define O2_SD_LED_ENABLE BIT(6) 47 #define O2_SD_FREG0_LEDOFF BIT(13) 48 #define O2_SD_FREG4_ENABLE_CLK_SET BIT(22) 49 50 #define O2_SD_VENDOR_SETTING 0x110 51 #define O2_SD_VENDOR_SETTING2 0x1C8 52 #define O2_SD_HW_TUNING_DISABLE BIT(4) 53 54 #define O2_PLL_WDT_CONTROL1 0x1CC 55 #define O2_PLL_FORCE_ACTIVE BIT(18) 56 #define O2_PLL_LOCK_STATUS BIT(14) 57 #define O2_PLL_SOFT_RESET BIT(12) 58 59 #define O2_SD_DETECT_SETTING 0x324 60 61 static void sdhci_o2_set_tuning_mode(struct sdhci_host *host) 62 { 63 u16 reg; 64 65 /* enable hardware tuning */ 66 reg = sdhci_readw(host, O2_SD_VENDOR_SETTING); 67 reg &= ~O2_SD_HW_TUNING_DISABLE; 68 sdhci_writew(host, reg, O2_SD_VENDOR_SETTING); 69 } 70 71 static void __sdhci_o2_execute_tuning(struct sdhci_host *host, u32 opcode) 72 { 73 int i; 74 75 sdhci_send_tuning(host, MMC_SEND_TUNING_BLOCK_HS200); 76 77 for (i = 0; i < 150; i++) { 78 u16 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); 79 80 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING)) { 81 if (ctrl & SDHCI_CTRL_TUNED_CLK) { 82 host->tuning_done = true; 83 return; 84 } 85 pr_warn("%s: HW tuning failed !\n", 86 mmc_hostname(host->mmc)); 87 break; 88 } 89 90 mdelay(1); 91 } 92 93 pr_info("%s: Tuning failed, falling back to fixed sampling clock\n", 94 mmc_hostname(host->mmc)); 95 sdhci_reset_tuning(host); 96 } 97 98 static int sdhci_o2_execute_tuning(struct mmc_host *mmc, u32 opcode) 99 { 100 struct sdhci_host *host = mmc_priv(mmc); 101 int current_bus_width = 0; 102 103 /* 104 * This handler only implements the eMMC tuning that is specific to 105 * this controller. Fall back to the standard method for other TIMING. 106 */ 107 if (host->timing != MMC_TIMING_MMC_HS200) 108 return sdhci_execute_tuning(mmc, opcode); 109 110 if (WARN_ON(opcode != MMC_SEND_TUNING_BLOCK_HS200)) 111 return -EINVAL; 112 113 /* 114 * o2 sdhci host didn't support 8bit emmc tuning 115 */ 116 if (mmc->ios.bus_width == MMC_BUS_WIDTH_8) { 117 current_bus_width = mmc->ios.bus_width; 118 mmc->ios.bus_width = MMC_BUS_WIDTH_4; 119 sdhci_set_bus_width(host, MMC_BUS_WIDTH_4); 120 } 121 122 sdhci_o2_set_tuning_mode(host); 123 124 sdhci_start_tuning(host); 125 126 __sdhci_o2_execute_tuning(host, opcode); 127 128 sdhci_end_tuning(host); 129 130 if (current_bus_width == MMC_BUS_WIDTH_8) { 131 mmc->ios.bus_width = MMC_BUS_WIDTH_8; 132 sdhci_set_bus_width(host, current_bus_width); 133 } 134 135 host->flags &= ~SDHCI_HS400_TUNING; 136 return 0; 137 } 138 139 static void o2_pci_set_baseclk(struct sdhci_pci_chip *chip, u32 value) 140 { 141 u32 scratch_32; 142 pci_read_config_dword(chip->pdev, 143 O2_SD_PLL_SETTING, &scratch_32); 144 145 scratch_32 &= 0x0000FFFF; 146 scratch_32 |= value; 147 148 pci_write_config_dword(chip->pdev, 149 O2_SD_PLL_SETTING, scratch_32); 150 } 151 152 static void o2_pci_led_enable(struct sdhci_pci_chip *chip) 153 { 154 int ret; 155 u32 scratch_32; 156 157 /* Set led of SD host function enable */ 158 ret = pci_read_config_dword(chip->pdev, 159 O2_SD_FUNC_REG0, &scratch_32); 160 if (ret) 161 return; 162 163 scratch_32 &= ~O2_SD_FREG0_LEDOFF; 164 pci_write_config_dword(chip->pdev, 165 O2_SD_FUNC_REG0, scratch_32); 166 167 ret = pci_read_config_dword(chip->pdev, 168 O2_SD_TEST_REG, &scratch_32); 169 if (ret) 170 return; 171 172 scratch_32 |= O2_SD_LED_ENABLE; 173 pci_write_config_dword(chip->pdev, 174 O2_SD_TEST_REG, scratch_32); 175 176 } 177 178 static void sdhci_pci_o2_fujin2_pci_init(struct sdhci_pci_chip *chip) 179 { 180 u32 scratch_32; 181 int ret; 182 /* Improve write performance for SD3.0 */ 183 ret = pci_read_config_dword(chip->pdev, O2_SD_DEV_CTRL, &scratch_32); 184 if (ret) 185 return; 186 scratch_32 &= ~((1 << 12) | (1 << 13) | (1 << 14)); 187 pci_write_config_dword(chip->pdev, O2_SD_DEV_CTRL, scratch_32); 188 189 /* Enable Link abnormal reset generating Reset */ 190 ret = pci_read_config_dword(chip->pdev, O2_SD_MISC_REG5, &scratch_32); 191 if (ret) 192 return; 193 scratch_32 &= ~((1 << 19) | (1 << 11)); 194 scratch_32 |= (1 << 10); 195 pci_write_config_dword(chip->pdev, O2_SD_MISC_REG5, scratch_32); 196 197 /* set card power over current protection */ 198 ret = pci_read_config_dword(chip->pdev, O2_SD_TEST_REG, &scratch_32); 199 if (ret) 200 return; 201 scratch_32 |= (1 << 4); 202 pci_write_config_dword(chip->pdev, O2_SD_TEST_REG, scratch_32); 203 204 /* adjust the output delay for SD mode */ 205 pci_write_config_dword(chip->pdev, O2_SD_DELAY_CTRL, 0x00002492); 206 207 /* Set the output voltage setting of Aux 1.2v LDO */ 208 ret = pci_read_config_dword(chip->pdev, O2_SD_LD0_CTRL, &scratch_32); 209 if (ret) 210 return; 211 scratch_32 &= ~(3 << 12); 212 pci_write_config_dword(chip->pdev, O2_SD_LD0_CTRL, scratch_32); 213 214 /* Set Max power supply capability of SD host */ 215 ret = pci_read_config_dword(chip->pdev, O2_SD_CAP_REG0, &scratch_32); 216 if (ret) 217 return; 218 scratch_32 &= ~(0x01FE); 219 scratch_32 |= 0x00CC; 220 pci_write_config_dword(chip->pdev, O2_SD_CAP_REG0, scratch_32); 221 /* Set DLL Tuning Window */ 222 ret = pci_read_config_dword(chip->pdev, 223 O2_SD_TUNING_CTRL, &scratch_32); 224 if (ret) 225 return; 226 scratch_32 &= ~(0x000000FF); 227 scratch_32 |= 0x00000066; 228 pci_write_config_dword(chip->pdev, O2_SD_TUNING_CTRL, scratch_32); 229 230 /* Set UHS2 T_EIDLE */ 231 ret = pci_read_config_dword(chip->pdev, 232 O2_SD_UHS2_L1_CTRL, &scratch_32); 233 if (ret) 234 return; 235 scratch_32 &= ~(0x000000FC); 236 scratch_32 |= 0x00000084; 237 pci_write_config_dword(chip->pdev, O2_SD_UHS2_L1_CTRL, scratch_32); 238 239 /* Set UHS2 Termination */ 240 ret = pci_read_config_dword(chip->pdev, O2_SD_FUNC_REG3, &scratch_32); 241 if (ret) 242 return; 243 scratch_32 &= ~((1 << 21) | (1 << 30)); 244 245 pci_write_config_dword(chip->pdev, O2_SD_FUNC_REG3, scratch_32); 246 247 /* Set L1 Entrance Timer */ 248 ret = pci_read_config_dword(chip->pdev, O2_SD_CAPS, &scratch_32); 249 if (ret) 250 return; 251 scratch_32 &= ~(0xf0000000); 252 scratch_32 |= 0x30000000; 253 pci_write_config_dword(chip->pdev, O2_SD_CAPS, scratch_32); 254 255 ret = pci_read_config_dword(chip->pdev, 256 O2_SD_MISC_CTRL4, &scratch_32); 257 if (ret) 258 return; 259 scratch_32 &= ~(0x000f0000); 260 scratch_32 |= 0x00080000; 261 pci_write_config_dword(chip->pdev, O2_SD_MISC_CTRL4, scratch_32); 262 } 263 264 static void sdhci_pci_o2_enable_msi(struct sdhci_pci_chip *chip, 265 struct sdhci_host *host) 266 { 267 int ret; 268 269 ret = pci_find_capability(chip->pdev, PCI_CAP_ID_MSI); 270 if (!ret) { 271 pr_info("%s: unsupport msi, use INTx irq\n", 272 mmc_hostname(host->mmc)); 273 return; 274 } 275 276 ret = pci_alloc_irq_vectors(chip->pdev, 1, 1, 277 PCI_IRQ_MSI | PCI_IRQ_MSIX); 278 if (ret < 0) { 279 pr_err("%s: enable PCI MSI failed, err=%d\n", 280 mmc_hostname(host->mmc), ret); 281 return; 282 } 283 284 host->irq = pci_irq_vector(chip->pdev, 0); 285 } 286 287 static void sdhci_o2_wait_card_detect_stable(struct sdhci_host *host) 288 { 289 ktime_t timeout; 290 u32 scratch32; 291 292 /* Wait max 50 ms */ 293 timeout = ktime_add_ms(ktime_get(), 50); 294 while (1) { 295 bool timedout = ktime_after(ktime_get(), timeout); 296 297 scratch32 = sdhci_readl(host, SDHCI_PRESENT_STATE); 298 if ((scratch32 & SDHCI_CARD_PRESENT) >> SDHCI_CARD_PRES_SHIFT 299 == (scratch32 & SDHCI_CD_LVL) >> SDHCI_CD_LVL_SHIFT) 300 break; 301 302 if (timedout) { 303 pr_err("%s: Card Detect debounce never finished.\n", 304 mmc_hostname(host->mmc)); 305 sdhci_dumpregs(host); 306 return; 307 } 308 udelay(10); 309 } 310 } 311 312 static void sdhci_o2_enable_internal_clock(struct sdhci_host *host) 313 { 314 ktime_t timeout; 315 u16 scratch; 316 u32 scratch32; 317 318 /* PLL software reset */ 319 scratch32 = sdhci_readl(host, O2_PLL_WDT_CONTROL1); 320 scratch32 |= O2_PLL_SOFT_RESET; 321 sdhci_writel(host, scratch32, O2_PLL_WDT_CONTROL1); 322 udelay(1); 323 scratch32 &= ~(O2_PLL_SOFT_RESET); 324 sdhci_writel(host, scratch32, O2_PLL_WDT_CONTROL1); 325 326 /* PLL force active */ 327 scratch32 |= O2_PLL_FORCE_ACTIVE; 328 sdhci_writel(host, scratch32, O2_PLL_WDT_CONTROL1); 329 330 /* Wait max 20 ms */ 331 timeout = ktime_add_ms(ktime_get(), 20); 332 while (1) { 333 bool timedout = ktime_after(ktime_get(), timeout); 334 335 scratch = sdhci_readw(host, O2_PLL_WDT_CONTROL1); 336 if (scratch & O2_PLL_LOCK_STATUS) 337 break; 338 if (timedout) { 339 pr_err("%s: Internal clock never stabilised.\n", 340 mmc_hostname(host->mmc)); 341 sdhci_dumpregs(host); 342 goto out; 343 } 344 udelay(10); 345 } 346 347 /* Wait for card detect finish */ 348 udelay(1); 349 sdhci_o2_wait_card_detect_stable(host); 350 351 out: 352 /* Cancel PLL force active */ 353 scratch32 = sdhci_readl(host, O2_PLL_WDT_CONTROL1); 354 scratch32 &= ~O2_PLL_FORCE_ACTIVE; 355 sdhci_writel(host, scratch32, O2_PLL_WDT_CONTROL1); 356 } 357 358 static int sdhci_o2_get_cd(struct mmc_host *mmc) 359 { 360 struct sdhci_host *host = mmc_priv(mmc); 361 362 sdhci_o2_enable_internal_clock(host); 363 364 return !!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT); 365 } 366 367 static void sdhci_o2_enable_clk(struct sdhci_host *host, u16 clk) 368 { 369 /* Enable internal clock */ 370 clk |= SDHCI_CLOCK_INT_EN; 371 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL); 372 373 if (sdhci_o2_get_cd(host->mmc)) { 374 clk |= SDHCI_CLOCK_CARD_EN; 375 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL); 376 } 377 } 378 379 void sdhci_pci_o2_set_clock(struct sdhci_host *host, unsigned int clock) 380 { 381 u16 clk; 382 383 host->mmc->actual_clock = 0; 384 385 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL); 386 387 if (clock == 0) 388 return; 389 390 clk = sdhci_calc_clk(host, clock, &host->mmc->actual_clock); 391 sdhci_o2_enable_clk(host, clk); 392 } 393 394 int sdhci_pci_o2_probe_slot(struct sdhci_pci_slot *slot) 395 { 396 struct sdhci_pci_chip *chip; 397 struct sdhci_host *host; 398 u32 reg, caps; 399 int ret; 400 401 chip = slot->chip; 402 host = slot->host; 403 404 caps = sdhci_readl(host, SDHCI_CAPABILITIES); 405 406 /* 407 * mmc_select_bus_width() will test the bus to determine the actual bus 408 * width. 409 */ 410 if (caps & SDHCI_CAN_DO_8BIT) 411 host->mmc->caps |= MMC_CAP_8_BIT_DATA; 412 413 switch (chip->pdev->device) { 414 case PCI_DEVICE_ID_O2_SDS0: 415 case PCI_DEVICE_ID_O2_SEABIRD0: 416 case PCI_DEVICE_ID_O2_SEABIRD1: 417 case PCI_DEVICE_ID_O2_SDS1: 418 case PCI_DEVICE_ID_O2_FUJIN2: 419 reg = sdhci_readl(host, O2_SD_VENDOR_SETTING); 420 if (reg & 0x1) 421 host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; 422 423 sdhci_pci_o2_enable_msi(chip, host); 424 425 if (chip->pdev->device == PCI_DEVICE_ID_O2_SEABIRD0) { 426 ret = pci_read_config_dword(chip->pdev, 427 O2_SD_MISC_SETTING, ®); 428 if (ret) 429 return -EIO; 430 if (reg & (1 << 4)) { 431 pr_info("%s: emmc 1.8v flag is set, force 1.8v signaling voltage\n", 432 mmc_hostname(host->mmc)); 433 host->flags &= ~SDHCI_SIGNALING_330; 434 host->flags |= SDHCI_SIGNALING_180; 435 host->quirks2 |= SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD; 436 host->mmc->caps2 |= MMC_CAP2_NO_SD; 437 host->mmc->caps2 |= MMC_CAP2_NO_SDIO; 438 pci_write_config_dword(chip->pdev, 439 O2_SD_DETECT_SETTING, 3); 440 } 441 442 slot->host->mmc_host_ops.get_cd = sdhci_o2_get_cd; 443 } 444 445 host->mmc_host_ops.execute_tuning = sdhci_o2_execute_tuning; 446 447 if (chip->pdev->device != PCI_DEVICE_ID_O2_FUJIN2) 448 break; 449 /* set dll watch dog timer */ 450 reg = sdhci_readl(host, O2_SD_VENDOR_SETTING2); 451 reg |= (1 << 12); 452 sdhci_writel(host, reg, O2_SD_VENDOR_SETTING2); 453 454 break; 455 default: 456 break; 457 } 458 459 return 0; 460 } 461 462 int sdhci_pci_o2_probe(struct sdhci_pci_chip *chip) 463 { 464 int ret; 465 u8 scratch; 466 u32 scratch_32; 467 468 switch (chip->pdev->device) { 469 case PCI_DEVICE_ID_O2_8220: 470 case PCI_DEVICE_ID_O2_8221: 471 case PCI_DEVICE_ID_O2_8320: 472 case PCI_DEVICE_ID_O2_8321: 473 /* This extra setup is required due to broken ADMA. */ 474 ret = pci_read_config_byte(chip->pdev, 475 O2_SD_LOCK_WP, &scratch); 476 if (ret) 477 return ret; 478 scratch &= 0x7f; 479 pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch); 480 481 /* Set Multi 3 to VCC3V# */ 482 pci_write_config_byte(chip->pdev, O2_SD_MULTI_VCC3V, 0x08); 483 484 /* Disable CLK_REQ# support after media DET */ 485 ret = pci_read_config_byte(chip->pdev, 486 O2_SD_CLKREQ, &scratch); 487 if (ret) 488 return ret; 489 scratch |= 0x20; 490 pci_write_config_byte(chip->pdev, O2_SD_CLKREQ, scratch); 491 492 /* Choose capabilities, enable SDMA. We have to write 0x01 493 * to the capabilities register first to unlock it. 494 */ 495 ret = pci_read_config_byte(chip->pdev, O2_SD_CAPS, &scratch); 496 if (ret) 497 return ret; 498 scratch |= 0x01; 499 pci_write_config_byte(chip->pdev, O2_SD_CAPS, scratch); 500 pci_write_config_byte(chip->pdev, O2_SD_CAPS, 0x73); 501 502 /* Disable ADMA1/2 */ 503 pci_write_config_byte(chip->pdev, O2_SD_ADMA1, 0x39); 504 pci_write_config_byte(chip->pdev, O2_SD_ADMA2, 0x08); 505 506 /* Disable the infinite transfer mode */ 507 ret = pci_read_config_byte(chip->pdev, 508 O2_SD_INF_MOD, &scratch); 509 if (ret) 510 return ret; 511 scratch |= 0x08; 512 pci_write_config_byte(chip->pdev, O2_SD_INF_MOD, scratch); 513 514 /* Lock WP */ 515 ret = pci_read_config_byte(chip->pdev, 516 O2_SD_LOCK_WP, &scratch); 517 if (ret) 518 return ret; 519 scratch |= 0x80; 520 pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch); 521 break; 522 case PCI_DEVICE_ID_O2_SDS0: 523 case PCI_DEVICE_ID_O2_SDS1: 524 case PCI_DEVICE_ID_O2_FUJIN2: 525 /* UnLock WP */ 526 ret = pci_read_config_byte(chip->pdev, 527 O2_SD_LOCK_WP, &scratch); 528 if (ret) 529 return ret; 530 531 scratch &= 0x7f; 532 pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch); 533 534 /* DevId=8520 subId= 0x11 or 0x12 Type Chip support */ 535 if (chip->pdev->device == PCI_DEVICE_ID_O2_FUJIN2) { 536 ret = pci_read_config_dword(chip->pdev, 537 O2_SD_FUNC_REG0, 538 &scratch_32); 539 scratch_32 = ((scratch_32 & 0xFF000000) >> 24); 540 541 /* Check Whether subId is 0x11 or 0x12 */ 542 if ((scratch_32 == 0x11) || (scratch_32 == 0x12)) { 543 scratch_32 = 0x25100000; 544 545 o2_pci_set_baseclk(chip, scratch_32); 546 ret = pci_read_config_dword(chip->pdev, 547 O2_SD_FUNC_REG4, 548 &scratch_32); 549 550 /* Enable Base Clk setting change */ 551 scratch_32 |= O2_SD_FREG4_ENABLE_CLK_SET; 552 pci_write_config_dword(chip->pdev, 553 O2_SD_FUNC_REG4, 554 scratch_32); 555 556 /* Set Tuning Window to 4 */ 557 pci_write_config_byte(chip->pdev, 558 O2_SD_TUNING_CTRL, 0x44); 559 560 break; 561 } 562 } 563 564 /* Enable 8520 led function */ 565 o2_pci_led_enable(chip); 566 567 /* Set timeout CLK */ 568 ret = pci_read_config_dword(chip->pdev, 569 O2_SD_CLK_SETTING, &scratch_32); 570 if (ret) 571 return ret; 572 573 scratch_32 &= ~(0xFF00); 574 scratch_32 |= 0x07E0C800; 575 pci_write_config_dword(chip->pdev, 576 O2_SD_CLK_SETTING, scratch_32); 577 578 ret = pci_read_config_dword(chip->pdev, 579 O2_SD_CLKREQ, &scratch_32); 580 if (ret) 581 return ret; 582 scratch_32 |= 0x3; 583 pci_write_config_dword(chip->pdev, O2_SD_CLKREQ, scratch_32); 584 585 ret = pci_read_config_dword(chip->pdev, 586 O2_SD_PLL_SETTING, &scratch_32); 587 if (ret) 588 return ret; 589 590 scratch_32 &= ~(0x1F3F070E); 591 scratch_32 |= 0x18270106; 592 pci_write_config_dword(chip->pdev, 593 O2_SD_PLL_SETTING, scratch_32); 594 595 /* Disable UHS1 funciton */ 596 ret = pci_read_config_dword(chip->pdev, 597 O2_SD_CAP_REG2, &scratch_32); 598 if (ret) 599 return ret; 600 scratch_32 &= ~(0xE0); 601 pci_write_config_dword(chip->pdev, 602 O2_SD_CAP_REG2, scratch_32); 603 604 if (chip->pdev->device == PCI_DEVICE_ID_O2_FUJIN2) 605 sdhci_pci_o2_fujin2_pci_init(chip); 606 607 /* Lock WP */ 608 ret = pci_read_config_byte(chip->pdev, 609 O2_SD_LOCK_WP, &scratch); 610 if (ret) 611 return ret; 612 scratch |= 0x80; 613 pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch); 614 break; 615 case PCI_DEVICE_ID_O2_SEABIRD0: 616 case PCI_DEVICE_ID_O2_SEABIRD1: 617 /* UnLock WP */ 618 ret = pci_read_config_byte(chip->pdev, 619 O2_SD_LOCK_WP, &scratch); 620 if (ret) 621 return ret; 622 623 scratch &= 0x7f; 624 pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch); 625 626 ret = pci_read_config_dword(chip->pdev, 627 O2_SD_PLL_SETTING, &scratch_32); 628 629 if ((scratch_32 & 0xff000000) == 0x01000000) { 630 scratch_32 &= 0x0000FFFF; 631 scratch_32 |= 0x1F340000; 632 633 pci_write_config_dword(chip->pdev, 634 O2_SD_PLL_SETTING, scratch_32); 635 } else { 636 scratch_32 &= 0x0000FFFF; 637 scratch_32 |= 0x25100000; 638 639 pci_write_config_dword(chip->pdev, 640 O2_SD_PLL_SETTING, scratch_32); 641 642 ret = pci_read_config_dword(chip->pdev, 643 O2_SD_FUNC_REG4, 644 &scratch_32); 645 scratch_32 |= (1 << 22); 646 pci_write_config_dword(chip->pdev, 647 O2_SD_FUNC_REG4, scratch_32); 648 } 649 650 /* Set Tuning Windows to 5 */ 651 pci_write_config_byte(chip->pdev, 652 O2_SD_TUNING_CTRL, 0x55); 653 /* Lock WP */ 654 ret = pci_read_config_byte(chip->pdev, 655 O2_SD_LOCK_WP, &scratch); 656 if (ret) 657 return ret; 658 scratch |= 0x80; 659 pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch); 660 break; 661 } 662 663 return 0; 664 } 665 666 #ifdef CONFIG_PM_SLEEP 667 int sdhci_pci_o2_resume(struct sdhci_pci_chip *chip) 668 { 669 sdhci_pci_o2_probe(chip); 670 return sdhci_pci_resume_host(chip); 671 } 672 #endif 673 674 static const struct sdhci_ops sdhci_pci_o2_ops = { 675 .set_clock = sdhci_pci_o2_set_clock, 676 .enable_dma = sdhci_pci_enable_dma, 677 .set_bus_width = sdhci_set_bus_width, 678 .reset = sdhci_reset, 679 .set_uhs_signaling = sdhci_set_uhs_signaling, 680 }; 681 682 const struct sdhci_pci_fixes sdhci_o2 = { 683 .probe = sdhci_pci_o2_probe, 684 .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, 685 .probe_slot = sdhci_pci_o2_probe_slot, 686 #ifdef CONFIG_PM_SLEEP 687 .resume = sdhci_pci_o2_resume, 688 #endif 689 .ops = &sdhci_pci_o2_ops, 690 }; 691