1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/arch/arm/mach-omap2/board-n8x0.c 4 * 5 * Copyright (C) 2005-2009 Nokia Corporation 6 * Author: Juha Yrjola <juha.yrjola@nokia.com> 7 * 8 * Modified from mach-omap2/board-generic.c 9 */ 10 11 #include <linux/clk.h> 12 #include <linux/delay.h> 13 #include <linux/gpio.h> 14 #include <linux/init.h> 15 #include <linux/io.h> 16 #include <linux/irq.h> 17 #include <linux/stddef.h> 18 #include <linux/i2c.h> 19 #include <linux/spi/spi.h> 20 #include <linux/usb/musb.h> 21 #include <linux/mmc/host.h> 22 #include <linux/platform_data/spi-omap2-mcspi.h> 23 #include <linux/platform_data/mmc-omap.h> 24 #include <linux/mfd/menelaus.h> 25 26 #include <asm/mach/arch.h> 27 #include <asm/mach-types.h> 28 29 #include "common.h" 30 #include "mmc.h" 31 #include "soc.h" 32 #include "common-board-devices.h" 33 34 #define TUSB6010_ASYNC_CS 1 35 #define TUSB6010_SYNC_CS 4 36 #define TUSB6010_GPIO_INT 58 37 #define TUSB6010_GPIO_ENABLE 0 38 #define TUSB6010_DMACHAN 0x3f 39 40 #define NOKIA_N810_WIMAX (1 << 2) 41 #define NOKIA_N810 (1 << 1) 42 #define NOKIA_N800 (1 << 0) 43 44 static u32 board_caps; 45 46 #define board_is_n800() (board_caps & NOKIA_N800) 47 #define board_is_n810() (board_caps & NOKIA_N810) 48 #define board_is_n810_wimax() (board_caps & NOKIA_N810_WIMAX) 49 50 static void board_check_revision(void) 51 { 52 if (of_machine_is_compatible("nokia,n800")) 53 board_caps = NOKIA_N800; 54 else if (of_machine_is_compatible("nokia,n810")) 55 board_caps = NOKIA_N810; 56 else if (of_machine_is_compatible("nokia,n810-wimax")) 57 board_caps = NOKIA_N810_WIMAX; 58 59 if (!board_caps) 60 pr_err("Unknown board\n"); 61 } 62 63 #if IS_ENABLED(CONFIG_USB_MUSB_TUSB6010) 64 /* 65 * Enable or disable power to TUSB6010. When enabling, turn on 3.3 V and 66 * 1.5 V voltage regulators of PM companion chip. Companion chip will then 67 * provide then PGOOD signal to TUSB6010 which will release it from reset. 68 */ 69 static int tusb_set_power(int state) 70 { 71 int i, retval = 0; 72 73 if (state) { 74 gpio_set_value(TUSB6010_GPIO_ENABLE, 1); 75 msleep(1); 76 77 /* Wait until TUSB6010 pulls INT pin down */ 78 i = 100; 79 while (i && gpio_get_value(TUSB6010_GPIO_INT)) { 80 msleep(1); 81 i--; 82 } 83 84 if (!i) { 85 printk(KERN_ERR "tusb: powerup failed\n"); 86 retval = -ENODEV; 87 } 88 } else { 89 gpio_set_value(TUSB6010_GPIO_ENABLE, 0); 90 msleep(10); 91 } 92 93 return retval; 94 } 95 96 static struct musb_hdrc_config musb_config = { 97 .multipoint = 1, 98 .dyn_fifo = 1, 99 .num_eps = 16, 100 .ram_bits = 12, 101 }; 102 103 static struct musb_hdrc_platform_data tusb_data = { 104 .mode = MUSB_OTG, 105 .set_power = tusb_set_power, 106 .min_power = 25, /* x2 = 50 mA drawn from VBUS as peripheral */ 107 .power = 100, /* Max 100 mA VBUS for host mode */ 108 .config = &musb_config, 109 }; 110 111 static void __init n8x0_usb_init(void) 112 { 113 int ret = 0; 114 static const char announce[] __initconst = KERN_INFO "TUSB 6010\n"; 115 116 /* PM companion chip power control pin */ 117 ret = gpio_request_one(TUSB6010_GPIO_ENABLE, GPIOF_OUT_INIT_LOW, 118 "TUSB6010 enable"); 119 if (ret != 0) { 120 printk(KERN_ERR "Could not get TUSB power GPIO%i\n", 121 TUSB6010_GPIO_ENABLE); 122 return; 123 } 124 tusb_set_power(0); 125 126 ret = tusb6010_setup_interface(&tusb_data, TUSB6010_REFCLK_19, 2, 127 TUSB6010_ASYNC_CS, TUSB6010_SYNC_CS, 128 TUSB6010_GPIO_INT, TUSB6010_DMACHAN); 129 if (ret != 0) 130 goto err; 131 132 printk(announce); 133 134 return; 135 136 err: 137 gpio_free(TUSB6010_GPIO_ENABLE); 138 } 139 #else 140 141 static void __init n8x0_usb_init(void) {} 142 143 #endif /*CONFIG_USB_MUSB_TUSB6010 */ 144 145 146 static struct omap2_mcspi_device_config p54spi_mcspi_config = { 147 .turbo_mode = 0, 148 }; 149 150 static struct spi_board_info n800_spi_board_info[] __initdata = { 151 { 152 .modalias = "p54spi", 153 .bus_num = 2, 154 .chip_select = 0, 155 .max_speed_hz = 48000000, 156 .controller_data = &p54spi_mcspi_config, 157 }, 158 }; 159 160 #if defined(CONFIG_MENELAUS) && IS_ENABLED(CONFIG_MMC_OMAP) 161 162 /* 163 * On both N800 and N810, only the first of the two MMC controllers is in use. 164 * The two MMC slots are multiplexed via Menelaus companion chip over I2C. 165 * On N800, both slots are powered via Menelaus. On N810, only one of the 166 * slots is powered via Menelaus. The N810 EMMC is powered via GPIO. 167 * 168 * VMMC slot 1 on both N800 and N810 169 * VDCDC3_APE and VMCS2_APE slot 2 on N800 170 * GPIO23 and GPIO9 slot 2 EMMC on N810 171 * 172 */ 173 #define N8X0_SLOT_SWITCH_GPIO 96 174 #define N810_EMMC_VSD_GPIO 23 175 #define N810_EMMC_VIO_GPIO 9 176 177 static int slot1_cover_open; 178 static int slot2_cover_open; 179 static struct device *mmc_device; 180 181 static int n8x0_mmc_switch_slot(struct device *dev, int slot) 182 { 183 #ifdef CONFIG_MMC_DEBUG 184 dev_dbg(dev, "Choose slot %d\n", slot + 1); 185 #endif 186 gpio_set_value(N8X0_SLOT_SWITCH_GPIO, slot); 187 return 0; 188 } 189 190 static int n8x0_mmc_set_power_menelaus(struct device *dev, int slot, 191 int power_on, int vdd) 192 { 193 int mV; 194 195 #ifdef CONFIG_MMC_DEBUG 196 dev_dbg(dev, "Set slot %d power: %s (vdd %d)\n", slot + 1, 197 power_on ? "on" : "off", vdd); 198 #endif 199 if (slot == 0) { 200 if (!power_on) 201 return menelaus_set_vmmc(0); 202 switch (1 << vdd) { 203 case MMC_VDD_33_34: 204 case MMC_VDD_32_33: 205 case MMC_VDD_31_32: 206 mV = 3100; 207 break; 208 case MMC_VDD_30_31: 209 mV = 3000; 210 break; 211 case MMC_VDD_28_29: 212 mV = 2800; 213 break; 214 case MMC_VDD_165_195: 215 mV = 1850; 216 break; 217 default: 218 BUG(); 219 } 220 return menelaus_set_vmmc(mV); 221 } else { 222 if (!power_on) 223 return menelaus_set_vdcdc(3, 0); 224 switch (1 << vdd) { 225 case MMC_VDD_33_34: 226 case MMC_VDD_32_33: 227 mV = 3300; 228 break; 229 case MMC_VDD_30_31: 230 case MMC_VDD_29_30: 231 mV = 3000; 232 break; 233 case MMC_VDD_28_29: 234 case MMC_VDD_27_28: 235 mV = 2800; 236 break; 237 case MMC_VDD_24_25: 238 case MMC_VDD_23_24: 239 mV = 2400; 240 break; 241 case MMC_VDD_22_23: 242 case MMC_VDD_21_22: 243 mV = 2200; 244 break; 245 case MMC_VDD_20_21: 246 mV = 2000; 247 break; 248 case MMC_VDD_165_195: 249 mV = 1800; 250 break; 251 default: 252 BUG(); 253 } 254 return menelaus_set_vdcdc(3, mV); 255 } 256 return 0; 257 } 258 259 static void n810_set_power_emmc(struct device *dev, 260 int power_on) 261 { 262 dev_dbg(dev, "Set EMMC power %s\n", power_on ? "on" : "off"); 263 264 if (power_on) { 265 gpio_set_value(N810_EMMC_VSD_GPIO, 1); 266 msleep(1); 267 gpio_set_value(N810_EMMC_VIO_GPIO, 1); 268 msleep(1); 269 } else { 270 gpio_set_value(N810_EMMC_VIO_GPIO, 0); 271 msleep(50); 272 gpio_set_value(N810_EMMC_VSD_GPIO, 0); 273 msleep(50); 274 } 275 } 276 277 static int n8x0_mmc_set_power(struct device *dev, int slot, int power_on, 278 int vdd) 279 { 280 if (board_is_n800() || slot == 0) 281 return n8x0_mmc_set_power_menelaus(dev, slot, power_on, vdd); 282 283 n810_set_power_emmc(dev, power_on); 284 285 return 0; 286 } 287 288 static int n8x0_mmc_set_bus_mode(struct device *dev, int slot, int bus_mode) 289 { 290 int r; 291 292 dev_dbg(dev, "Set slot %d bus mode %s\n", slot + 1, 293 bus_mode == MMC_BUSMODE_OPENDRAIN ? "open-drain" : "push-pull"); 294 BUG_ON(slot != 0 && slot != 1); 295 slot++; 296 switch (bus_mode) { 297 case MMC_BUSMODE_OPENDRAIN: 298 r = menelaus_set_mmc_opendrain(slot, 1); 299 break; 300 case MMC_BUSMODE_PUSHPULL: 301 r = menelaus_set_mmc_opendrain(slot, 0); 302 break; 303 default: 304 BUG(); 305 } 306 if (r != 0 && printk_ratelimit()) 307 dev_err(dev, "MMC: unable to set bus mode for slot %d\n", 308 slot); 309 return r; 310 } 311 312 static int n8x0_mmc_get_cover_state(struct device *dev, int slot) 313 { 314 slot++; 315 BUG_ON(slot != 1 && slot != 2); 316 if (slot == 1) 317 return slot1_cover_open; 318 else 319 return slot2_cover_open; 320 } 321 322 static void n8x0_mmc_callback(void *data, u8 card_mask) 323 { 324 #ifdef CONFIG_MMC_OMAP 325 int bit, *openp, index; 326 327 if (board_is_n800()) { 328 bit = 1 << 1; 329 openp = &slot2_cover_open; 330 index = 1; 331 } else { 332 bit = 1; 333 openp = &slot1_cover_open; 334 index = 0; 335 } 336 337 if (card_mask & bit) 338 *openp = 1; 339 else 340 *openp = 0; 341 342 omap_mmc_notify_cover_event(mmc_device, index, *openp); 343 #else 344 pr_warn("MMC: notify cover event not available\n"); 345 #endif 346 } 347 348 static int n8x0_mmc_late_init(struct device *dev) 349 { 350 int r, bit, *openp; 351 int vs2sel; 352 353 mmc_device = dev; 354 355 r = menelaus_set_slot_sel(1); 356 if (r < 0) 357 return r; 358 359 if (board_is_n800()) 360 vs2sel = 0; 361 else 362 vs2sel = 2; 363 364 r = menelaus_set_mmc_slot(2, 0, vs2sel, 1); 365 if (r < 0) 366 return r; 367 368 n8x0_mmc_set_power(dev, 0, MMC_POWER_ON, 16); /* MMC_VDD_28_29 */ 369 n8x0_mmc_set_power(dev, 1, MMC_POWER_ON, 16); 370 371 r = menelaus_set_mmc_slot(1, 1, 0, 1); 372 if (r < 0) 373 return r; 374 r = menelaus_set_mmc_slot(2, 1, vs2sel, 1); 375 if (r < 0) 376 return r; 377 378 r = menelaus_get_slot_pin_states(); 379 if (r < 0) 380 return r; 381 382 if (board_is_n800()) { 383 bit = 1 << 1; 384 openp = &slot2_cover_open; 385 } else { 386 bit = 1; 387 openp = &slot1_cover_open; 388 slot2_cover_open = 0; 389 } 390 391 /* All slot pin bits seem to be inversed until first switch change */ 392 if (r == 0xf || r == (0xf & ~bit)) 393 r = ~r; 394 395 if (r & bit) 396 *openp = 1; 397 else 398 *openp = 0; 399 400 r = menelaus_register_mmc_callback(n8x0_mmc_callback, NULL); 401 402 return r; 403 } 404 405 static void n8x0_mmc_shutdown(struct device *dev) 406 { 407 int vs2sel; 408 409 if (board_is_n800()) 410 vs2sel = 0; 411 else 412 vs2sel = 2; 413 414 menelaus_set_mmc_slot(1, 0, 0, 0); 415 menelaus_set_mmc_slot(2, 0, vs2sel, 0); 416 } 417 418 static void n8x0_mmc_cleanup(struct device *dev) 419 { 420 menelaus_unregister_mmc_callback(); 421 422 gpio_free(N8X0_SLOT_SWITCH_GPIO); 423 424 if (board_is_n810()) { 425 gpio_free(N810_EMMC_VSD_GPIO); 426 gpio_free(N810_EMMC_VIO_GPIO); 427 } 428 } 429 430 /* 431 * MMC controller1 has two slots that are multiplexed via I2C. 432 * MMC controller2 is not in use. 433 */ 434 static struct omap_mmc_platform_data mmc1_data = { 435 .nr_slots = 0, 436 .switch_slot = n8x0_mmc_switch_slot, 437 .init = n8x0_mmc_late_init, 438 .cleanup = n8x0_mmc_cleanup, 439 .shutdown = n8x0_mmc_shutdown, 440 .max_freq = 24000000, 441 .slots[0] = { 442 .wires = 4, 443 .set_power = n8x0_mmc_set_power, 444 .set_bus_mode = n8x0_mmc_set_bus_mode, 445 .get_cover_state = n8x0_mmc_get_cover_state, 446 .ocr_mask = MMC_VDD_165_195 | MMC_VDD_30_31 | 447 MMC_VDD_32_33 | MMC_VDD_33_34, 448 .name = "internal", 449 }, 450 .slots[1] = { 451 .set_power = n8x0_mmc_set_power, 452 .set_bus_mode = n8x0_mmc_set_bus_mode, 453 .get_cover_state = n8x0_mmc_get_cover_state, 454 .ocr_mask = MMC_VDD_165_195 | MMC_VDD_20_21 | 455 MMC_VDD_21_22 | MMC_VDD_22_23 | 456 MMC_VDD_23_24 | MMC_VDD_24_25 | 457 MMC_VDD_27_28 | MMC_VDD_28_29 | 458 MMC_VDD_29_30 | MMC_VDD_30_31 | 459 MMC_VDD_32_33 | MMC_VDD_33_34, 460 .name = "external", 461 }, 462 }; 463 464 static struct omap_mmc_platform_data *mmc_data[OMAP24XX_NR_MMC]; 465 466 static struct gpio n810_emmc_gpios[] __initdata = { 467 { N810_EMMC_VSD_GPIO, GPIOF_OUT_INIT_LOW, "MMC slot 2 Vddf" }, 468 { N810_EMMC_VIO_GPIO, GPIOF_OUT_INIT_LOW, "MMC slot 2 Vdd" }, 469 }; 470 471 static void __init n8x0_mmc_init(void) 472 { 473 int err; 474 475 if (board_is_n810()) { 476 mmc1_data.slots[0].name = "external"; 477 478 /* 479 * Some Samsung Movinand chips do not like open-ended 480 * multi-block reads and fall to braind-dead state 481 * while doing so. Reducing the number of blocks in 482 * the transfer or delays in clock disable do not help 483 */ 484 mmc1_data.slots[1].name = "internal"; 485 mmc1_data.slots[1].ban_openended = 1; 486 } 487 488 err = gpio_request_one(N8X0_SLOT_SWITCH_GPIO, GPIOF_OUT_INIT_LOW, 489 "MMC slot switch"); 490 if (err) 491 return; 492 493 if (board_is_n810()) { 494 err = gpio_request_array(n810_emmc_gpios, 495 ARRAY_SIZE(n810_emmc_gpios)); 496 if (err) { 497 gpio_free(N8X0_SLOT_SWITCH_GPIO); 498 return; 499 } 500 } 501 502 mmc1_data.nr_slots = 2; 503 mmc_data[0] = &mmc1_data; 504 } 505 #else 506 static struct omap_mmc_platform_data mmc1_data; 507 static void __init n8x0_mmc_init(void) 508 { 509 } 510 #endif /* CONFIG_MMC_OMAP */ 511 512 #ifdef CONFIG_MENELAUS 513 514 static int n8x0_auto_sleep_regulators(void) 515 { 516 u32 val; 517 int ret; 518 519 val = EN_VPLL_SLEEP | EN_VMMC_SLEEP \ 520 | EN_VAUX_SLEEP | EN_VIO_SLEEP \ 521 | EN_VMEM_SLEEP | EN_DC3_SLEEP \ 522 | EN_VC_SLEEP | EN_DC2_SLEEP; 523 524 ret = menelaus_set_regulator_sleep(1, val); 525 if (ret < 0) { 526 pr_err("Could not set regulators to sleep on menelaus: %u\n", 527 ret); 528 return ret; 529 } 530 return 0; 531 } 532 533 static int n8x0_auto_voltage_scale(void) 534 { 535 int ret; 536 537 ret = menelaus_set_vcore_hw(1400, 1050); 538 if (ret < 0) { 539 pr_err("Could not set VCORE voltage on menelaus: %u\n", ret); 540 return ret; 541 } 542 return 0; 543 } 544 545 static int n8x0_menelaus_late_init(struct device *dev) 546 { 547 int ret; 548 549 ret = n8x0_auto_voltage_scale(); 550 if (ret < 0) 551 return ret; 552 ret = n8x0_auto_sleep_regulators(); 553 if (ret < 0) 554 return ret; 555 return 0; 556 } 557 558 #else 559 static int n8x0_menelaus_late_init(struct device *dev) 560 { 561 return 0; 562 } 563 #endif 564 565 struct menelaus_platform_data n8x0_menelaus_platform_data = { 566 .late_init = n8x0_menelaus_late_init, 567 }; 568 569 static int __init n8x0_late_initcall(void) 570 { 571 if (!board_caps) 572 return -ENODEV; 573 574 n8x0_mmc_init(); 575 n8x0_usb_init(); 576 577 return 0; 578 } 579 omap_late_initcall(n8x0_late_initcall); 580 581 /* 582 * Legacy init pdata init for n8x0. Note that we want to follow the 583 * I2C bus numbering starting at 0 for device tree like other omaps. 584 */ 585 void * __init n8x0_legacy_init(void) 586 { 587 board_check_revision(); 588 spi_register_board_info(n800_spi_board_info, 589 ARRAY_SIZE(n800_spi_board_info)); 590 return &mmc1_data; 591 } 592