hsmmc.c 12.9 KB
Newer Older
1
/*
2
 * linux/arch/arm/mach-omap2/hsmmc.c
3 4 5 6 7 8 9 10 11
 *
 * Copyright (C) 2007-2008 Texas Instruments
 * Copyright (C) 2008 Nokia Corporation
 * Author: Texas Instruments
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
12 13 14
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/string.h>
15 16
#include <linux/delay.h>
#include <mach/hardware.h>
17
#include <plat/mmc.h>
18
#include <plat/omap-pm.h>
19
#include <plat/mux.h>
20

21
#include "mux.h"
22
#include "hsmmc.h"
23
#include "control.h"
24

25
#if defined(CONFIG_MMC_OMAP_HS) || defined(CONFIG_MMC_OMAP_HS_MODULE)
26 27 28

static u16 control_pbias_offset;
static u16 control_devconf1_offset;
29
static u16 control_mmc1;
30 31 32

#define HSMMC_NAME_LEN	9

33
static struct hsmmc_controller {
34 35
	char				name[HSMMC_NAME_LEN + 1];
} hsmmc[OMAP34XX_NR_MMC];
36

37 38
#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_PM)

39
static int hsmmc_get_context_loss(struct device *dev)
40
{
41
	return omap_pm_get_dev_context_loss_count(dev);
42 43 44
}

#else
45
#define hsmmc_get_context_loss NULL
46 47
#endif

48
static void omap_hsmmc1_before_set_reg(struct device *dev, int slot,
49
				  int power_on, int vdd)
50
{
51
	u32 reg, prog_io;
52 53
	struct omap_mmc_platform_data *mmc = dev->platform_data;

54 55 56
	if (mmc->slots[0].remux)
		mmc->slots[0].remux(dev, slot, power_on);

57 58
	/*
	 * Assume we power both OMAP VMMC1 (for CMD, CLK, DAT0..3) and the
59
	 * card with Vcc regulator (from twl4030 or whatever).  OMAP has both
60 61 62 63
	 * 1.8V and 3.0V modes, controlled by the PBIAS register.
	 *
	 * In 8-bit modes, OMAP VMMC1A (for DAT4..7) needs a supply, which
	 * is most naturally TWL VSIM; those pins also use PBIAS.
64 65
	 *
	 * FIXME handle VMMC1A as needed ...
66
	 */
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
	if (power_on) {
		if (cpu_is_omap2430()) {
			reg = omap_ctrl_readl(OMAP243X_CONTROL_DEVCONF1);
			if ((1 << vdd) >= MMC_VDD_30_31)
				reg |= OMAP243X_MMC1_ACTIVE_OVERWRITE;
			else
				reg &= ~OMAP243X_MMC1_ACTIVE_OVERWRITE;
			omap_ctrl_writel(reg, OMAP243X_CONTROL_DEVCONF1);
		}

		if (mmc->slots[0].internal_clock) {
			reg = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0);
			reg |= OMAP2_MMCSDIO1ADPCLKISEL;
			omap_ctrl_writel(reg, OMAP2_CONTROL_DEVCONF0);
		}

		reg = omap_ctrl_readl(control_pbias_offset);
84 85 86 87 88 89 90 91
		if (cpu_is_omap3630()) {
			/* Set MMC I/O to 52Mhz */
			prog_io = omap_ctrl_readl(OMAP343X_CONTROL_PROG_IO1);
			prog_io |= OMAP3630_PRG_SDMMC1_SPEEDCTRL;
			omap_ctrl_writel(prog_io, OMAP343X_CONTROL_PROG_IO1);
		} else {
			reg |= OMAP2_PBIASSPEEDCTRL0;
		}
92 93
		reg &= ~OMAP2_PBIASLITEPWRDNZ0;
		omap_ctrl_writel(reg, control_pbias_offset);
94 95 96 97 98 99 100
	} else {
		reg = omap_ctrl_readl(control_pbias_offset);
		reg &= ~OMAP2_PBIASLITEPWRDNZ0;
		omap_ctrl_writel(reg, control_pbias_offset);
	}
}

101
static void omap_hsmmc1_after_set_reg(struct device *dev, int slot,
102 103 104
				 int power_on, int vdd)
{
	u32 reg;
105

106 107
	/* 100ms delay required for PBIAS configuration */
	msleep(100);
108

109
	if (power_on) {
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
		reg = omap_ctrl_readl(control_pbias_offset);
		reg |= (OMAP2_PBIASLITEPWRDNZ0 | OMAP2_PBIASSPEEDCTRL0);
		if ((1 << vdd) <= MMC_VDD_165_195)
			reg &= ~OMAP2_PBIASLITEVMODE0;
		else
			reg |= OMAP2_PBIASLITEVMODE0;
		omap_ctrl_writel(reg, control_pbias_offset);
	} else {
		reg = omap_ctrl_readl(control_pbias_offset);
		reg |= (OMAP2_PBIASSPEEDCTRL0 | OMAP2_PBIASLITEPWRDNZ0 |
			OMAP2_PBIASLITEVMODE0);
		omap_ctrl_writel(reg, control_pbias_offset);
	}
}

125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
static void omap4_hsmmc1_before_set_reg(struct device *dev, int slot,
				  int power_on, int vdd)
{
	u32 reg;

	/*
	 * Assume we power both OMAP VMMC1 (for CMD, CLK, DAT0..3) and the
	 * card with Vcc regulator (from twl4030 or whatever).  OMAP has both
	 * 1.8V and 3.0V modes, controlled by the PBIAS register.
	 *
	 * In 8-bit modes, OMAP VMMC1A (for DAT4..7) needs a supply, which
	 * is most naturally TWL VSIM; those pins also use PBIAS.
	 *
	 * FIXME handle VMMC1A as needed ...
	 */
140 141 142 143 144
	reg = omap4_ctrl_pad_readl(control_pbias_offset);
	reg &= ~(OMAP4_MMC1_PBIASLITE_PWRDNZ_MASK |
		OMAP4_MMC1_PWRDNZ_MASK |
		OMAP4_USBC1_ICUSB_PWRDNZ_MASK);
	omap4_ctrl_pad_writel(reg, control_pbias_offset);
145 146 147 148 149 150 151 152
}

static void omap4_hsmmc1_after_set_reg(struct device *dev, int slot,
				 int power_on, int vdd)
{
	u32 reg;

	if (power_on) {
153 154
		reg = omap4_ctrl_pad_readl(control_pbias_offset);
		reg |= OMAP4_MMC1_PBIASLITE_PWRDNZ_MASK;
155
		if ((1 << vdd) <= MMC_VDD_165_195)
156
			reg &= ~OMAP4_MMC1_PBIASLITE_VMODE_MASK;
157
		else
158 159 160 161 162
			reg |= OMAP4_MMC1_PBIASLITE_VMODE_MASK;
		reg |= (OMAP4_MMC1_PBIASLITE_PWRDNZ_MASK |
			OMAP4_MMC1_PWRDNZ_MASK |
			OMAP4_USBC1_ICUSB_PWRDNZ_MASK);
		omap4_ctrl_pad_writel(reg, control_pbias_offset);
163 164
		/* 4 microsec delay for comparator to generate an error*/
		udelay(4);
165 166
		reg = omap4_ctrl_pad_readl(control_pbias_offset);
		if (reg & OMAP4_MMC1_PBIASLITE_VMODE_ERROR_MASK) {
167 168
			pr_err("Pbias Voltage is not same as LDO\n");
			/* Caution : On VMODE_ERROR Power Down MMC IO */
169 170 171
			reg &= ~(OMAP4_MMC1_PWRDNZ_MASK |
				OMAP4_USBC1_ICUSB_PWRDNZ_MASK);
			omap4_ctrl_pad_writel(reg, control_pbias_offset);
172 173
		}
	} else {
174 175 176 177 178 179
		reg = omap4_ctrl_pad_readl(control_pbias_offset);
		reg |= (OMAP4_MMC1_PBIASLITE_PWRDNZ_MASK |
			OMAP4_MMC1_PWRDNZ_MASK |
			OMAP4_MMC1_PBIASLITE_VMODE_MASK |
			OMAP4_USBC1_ICUSB_PWRDNZ_MASK);
		omap4_ctrl_pad_writel(reg, control_pbias_offset);
180 181 182
	}
}

183 184
static void hsmmc23_before_set_reg(struct device *dev, int slot,
				   int power_on, int vdd)
185 186
{
	struct omap_mmc_platform_data *mmc = dev->platform_data;
187

188 189 190
	if (mmc->slots[0].remux)
		mmc->slots[0].remux(dev, slot, power_on);

191
	if (power_on) {
192
		/* Only MMC2 supports a CLKIN */
193 194 195 196 197 198 199
		if (mmc->slots[0].internal_clock) {
			u32 reg;

			reg = omap_ctrl_readl(control_devconf1_offset);
			reg |= OMAP2_MMCSDIO2ADPCLKISEL;
			omap_ctrl_writel(reg, control_devconf1_offset);
		}
200 201 202
	}
}

203 204 205 206 207 208
static int nop_mmc_set_power(struct device *dev, int slot, int power_on,
							int vdd)
{
	return 0;
}

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
static inline void omap_hsmmc_mux(struct omap_mmc_platform_data *mmc_controller,
			int controller_nr)
{
	if ((mmc_controller->slots[0].switch_pin > 0) && \
		(mmc_controller->slots[0].switch_pin < OMAP_MAX_GPIO_LINES))
		omap_mux_init_gpio(mmc_controller->slots[0].switch_pin,
					OMAP_PIN_INPUT_PULLUP);
	if ((mmc_controller->slots[0].gpio_wp > 0) && \
		(mmc_controller->slots[0].gpio_wp < OMAP_MAX_GPIO_LINES))
		omap_mux_init_gpio(mmc_controller->slots[0].gpio_wp,
					OMAP_PIN_INPUT_PULLUP);
	if (cpu_is_omap34xx()) {
		if (controller_nr == 0) {
			omap_mux_init_signal("sdmmc1_clk",
				OMAP_PIN_INPUT_PULLUP);
			omap_mux_init_signal("sdmmc1_cmd",
				OMAP_PIN_INPUT_PULLUP);
			omap_mux_init_signal("sdmmc1_dat0",
				OMAP_PIN_INPUT_PULLUP);
			if (mmc_controller->slots[0].caps &
				(MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)) {
				omap_mux_init_signal("sdmmc1_dat1",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc1_dat2",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc1_dat3",
					OMAP_PIN_INPUT_PULLUP);
			}
			if (mmc_controller->slots[0].caps &
						MMC_CAP_8_BIT_DATA) {
				omap_mux_init_signal("sdmmc1_dat4",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc1_dat5",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc1_dat6",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc1_dat7",
					OMAP_PIN_INPUT_PULLUP);
			}
		}
		if (controller_nr == 1) {
			/* MMC2 */
			omap_mux_init_signal("sdmmc2_clk",
				OMAP_PIN_INPUT_PULLUP);
			omap_mux_init_signal("sdmmc2_cmd",
				OMAP_PIN_INPUT_PULLUP);
			omap_mux_init_signal("sdmmc2_dat0",
				OMAP_PIN_INPUT_PULLUP);

			/*
			 * For 8 wire configurations, Lines DAT4, 5, 6 and 7
			 * need to be muxed in the board-*.c files
			 */
			if (mmc_controller->slots[0].caps &
				(MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)) {
				omap_mux_init_signal("sdmmc2_dat1",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc2_dat2",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc2_dat3",
					OMAP_PIN_INPUT_PULLUP);
			}
			if (mmc_controller->slots[0].caps &
							MMC_CAP_8_BIT_DATA) {
				omap_mux_init_signal("sdmmc2_dat4.sdmmc2_dat4",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc2_dat5.sdmmc2_dat5",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc2_dat6.sdmmc2_dat6",
					OMAP_PIN_INPUT_PULLUP);
				omap_mux_init_signal("sdmmc2_dat7.sdmmc2_dat7",
					OMAP_PIN_INPUT_PULLUP);
			}
		}

		/*
		 * For MMC3 the pins need to be muxed in the board-*.c files
		 */
	}
}

290 291
static struct omap_mmc_platform_data *hsmmc_data[OMAP34XX_NR_MMC] __initdata;

292
void __init omap2_hsmmc_init(struct omap2_hsmmc_info *controllers)
293
{
294
	struct omap2_hsmmc_info *c;
295
	int nr_hsmmc = ARRAY_SIZE(hsmmc_data);
A
Aaro Koskinen 已提交
296
	int i;
297
	u32 reg;
298

299 300 301 302 303 304 305 306
	if (!cpu_is_omap44xx()) {
		if (cpu_is_omap2430()) {
			control_pbias_offset = OMAP243X_CONTROL_PBIAS_LITE;
			control_devconf1_offset = OMAP243X_CONTROL_DEVCONF1;
		} else {
			control_pbias_offset = OMAP343X_CONTROL_PBIAS_LITE;
			control_devconf1_offset = OMAP343X_CONTROL_DEVCONF1;
		}
307
	} else {
308 309 310 311 312 313 314 315 316 317 318 319
		control_pbias_offset =
			OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_PBIASLITE;
		control_mmc1 = OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_MMC1;
		reg = omap4_ctrl_pad_readl(control_mmc1);
		reg |= (OMAP4_SDMMC1_PUSTRENGTH_GRP0_MASK |
			OMAP4_SDMMC1_PUSTRENGTH_GRP1_MASK);
		reg &= ~(OMAP4_SDMMC1_PUSTRENGTH_GRP2_MASK |
			OMAP4_SDMMC1_PUSTRENGTH_GRP3_MASK);
		reg |= (OMAP4_USBC1_DR0_SPEEDCTRL_MASK|
			OMAP4_SDMMC1_DR1_SPEEDCTRL_MASK |
			OMAP4_SDMMC1_DR2_SPEEDCTRL_MASK);
		omap4_ctrl_pad_writel(reg, control_mmc1);
320 321 322
	}

	for (c = controllers; c->mmc; c++) {
323
		struct hsmmc_controller *hc = hsmmc + c->mmc - 1;
324 325 326 327 328 329 330 331 332 333 334
		struct omap_mmc_platform_data *mmc = hsmmc_data[c->mmc - 1];

		if (!c->mmc || c->mmc > nr_hsmmc) {
			pr_debug("MMC%d: no such controller\n", c->mmc);
			continue;
		}
		if (mmc) {
			pr_debug("MMC%d: already configured\n", c->mmc);
			continue;
		}

335 336
		mmc = kzalloc(sizeof(struct omap_mmc_platform_data),
			      GFP_KERNEL);
337 338
		if (!mmc) {
			pr_err("Cannot allocate memory for mmc device!\n");
A
Aaro Koskinen 已提交
339
			goto done;
340 341
		}

342
		if (c->name)
343
			strncpy(hc->name, c->name, HSMMC_NAME_LEN);
344
		else
345
			snprintf(hc->name, ARRAY_SIZE(hc->name),
346
				"mmc%islot%i", c->mmc, 1);
347
		mmc->slots[0].name = hc->name;
348
		mmc->nr_slots = 1;
349
		mmc->slots[0].caps = c->caps;
350 351
		mmc->slots[0].internal_clock = !c->ext_clock;
		mmc->dma_mask = 0xffffffff;
352 353 354 355
		if (cpu_is_omap44xx())
			mmc->reg_offset = OMAP4_MMC_REG_OFFSET;
		else
			mmc->reg_offset = 0;
356

357
		mmc->get_context_loss_count = hsmmc_get_context_loss;
358

359 360
		mmc->slots[0].switch_pin = c->gpio_cd;
		mmc->slots[0].gpio_wp = c->gpio_wp;
361

362
		mmc->slots[0].remux = c->remux;
363
		mmc->slots[0].init_card = c->init_card;
364

365 366
		if (c->cover_only)
			mmc->slots[0].cover = 1;
367

368 369 370
		if (c->nonremovable)
			mmc->slots[0].nonremovable = 1;

371 372 373
		if (c->power_saving)
			mmc->slots[0].power_saving = 1;

374 375 376
		if (c->no_off)
			mmc->slots[0].no_off = 1;

377 378 379
		if (c->vcc_aux_disable_is_sleep)
			mmc->slots[0].vcc_aux_disable_is_sleep = 1;

380 381 382 383 384
		/* NOTE:  MMC slots should have a Vcc regulator set up.
		 * This may be from a TWL4030-family chip, another
		 * controllable regulator, or a fixed supply.
		 *
		 * temporary HACK: ocr_mask instead of fixed supply
385
		 */
386
		mmc->slots[0].ocr_mask = c->ocr_mask;
387

388 389 390 391 392
		if (cpu_is_omap3517() || cpu_is_omap3505())
			mmc->slots[0].set_power = nop_mmc_set_power;
		else
			mmc->slots[0].features |= HSMMC_HAS_PBIAS;

393 394 395
		if (cpu_is_omap44xx() && (omap_rev() > OMAP4430_REV_ES1_0))
			mmc->slots[0].features |= HSMMC_HAS_UPDATED_RESET;

396 397
		switch (c->mmc) {
		case 1:
398 399
			if (mmc->slots[0].features & HSMMC_HAS_PBIAS) {
				/* on-chip level shifting via PBIAS0/PBIAS1 */
400 401 402 403 404 405 406 407 408 409 410
				if (cpu_is_omap44xx()) {
					mmc->slots[0].before_set_reg =
						omap4_hsmmc1_before_set_reg;
					mmc->slots[0].after_set_reg =
						omap4_hsmmc1_after_set_reg;
				} else {
					mmc->slots[0].before_set_reg =
						omap_hsmmc1_before_set_reg;
					mmc->slots[0].after_set_reg =
						omap_hsmmc1_after_set_reg;
				}
411
			}
M
Madhu 已提交
412 413

			/* Omap3630 HSMMC1 supports only 4-bit */
414 415 416 417 418
			if (cpu_is_omap3630() &&
					(c->caps & MMC_CAP_8_BIT_DATA)) {
				c->caps &= ~MMC_CAP_8_BIT_DATA;
				c->caps |= MMC_CAP_4_BIT_DATA;
				mmc->slots[0].caps = c->caps;
M
Madhu 已提交
419
			}
420 421
			break;
		case 2:
422 423
			if (c->ext_clock)
				c->transceiver = 1;
424 425 426 427
			if (c->transceiver && (c->caps & MMC_CAP_8_BIT_DATA)) {
				c->caps &= ~MMC_CAP_8_BIT_DATA;
				c->caps |= MMC_CAP_4_BIT_DATA;
			}
428
			/* FALLTHROUGH */
429
		case 3:
430 431 432 433 434
			if (mmc->slots[0].features & HSMMC_HAS_PBIAS) {
				/* off-chip level shifting, or none */
				mmc->slots[0].before_set_reg = hsmmc23_before_set_reg;
				mmc->slots[0].after_set_reg = NULL;
			}
435
			break;
436 437 438 439 440
		case 4:
		case 5:
			mmc->slots[0].before_set_reg = NULL;
			mmc->slots[0].after_set_reg = NULL;
			break;
441 442
		default:
			pr_err("MMC%d configuration not supported!\n", c->mmc);
443
			kfree(mmc);
444 445 446
			continue;
		}
		hsmmc_data[c->mmc - 1] = mmc;
447
		omap_hsmmc_mux(hsmmc_data[c->mmc - 1], (c->mmc - 1));
448 449 450
	}

	omap2_init_mmc(hsmmc_data, OMAP34XX_NR_MMC);
451 452 453 454 455 456 457 458 459

	/* pass the device nodes back to board setup code */
	for (c = controllers; c->mmc; c++) {
		struct omap_mmc_platform_data *mmc = hsmmc_data[c->mmc - 1];

		if (!c->mmc || c->mmc > nr_hsmmc)
			continue;
		c->dev = mmc->dev;
	}
A
Aaro Koskinen 已提交
460 461 462 463

done:
	for (i = 0; i < nr_hsmmc; i++)
		kfree(hsmmc_data[i]);
464 465 466
}

#endif