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