2d36f3afbd4e884d07e9f3eae45d22ec661f10b9
[firefly-linux-kernel-4.4.55.git] / arch / arm / mach-omap2 / hsmmc.c
1 /*
2  * linux/arch/arm/mach-omap2/hsmmc.c
3  *
4  * Copyright (C) 2007-2008 Texas Instruments
5  * Copyright (C) 2008 Nokia Corporation
6  * Author: Texas Instruments
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/string.h>
15 #include <linux/delay.h>
16 #include <mach/hardware.h>
17 #include <plat/control.h>
18 #include <plat/mmc.h>
19 #include <plat/omap-pm.h>
20
21 #include "hsmmc.h"
22
23 #if defined(CONFIG_MMC_OMAP_HS) || defined(CONFIG_MMC_OMAP_HS_MODULE)
24
25 static u16 control_pbias_offset;
26 static u16 control_devconf1_offset;
27
28 #define HSMMC_NAME_LEN  9
29
30 static struct hsmmc_controller {
31         char                            name[HSMMC_NAME_LEN + 1];
32 } hsmmc[OMAP34XX_NR_MMC];
33
34 #if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_PM)
35
36 static int hsmmc_get_context_loss(struct device *dev)
37 {
38         return omap_pm_get_dev_context_loss_count(dev);
39 }
40
41 #else
42 #define hsmmc_get_context_loss NULL
43 #endif
44
45 static void hsmmc1_before_set_reg(struct device *dev, int slot,
46                                   int power_on, int vdd)
47 {
48         u32 reg, prog_io;
49         struct omap_mmc_platform_data *mmc = dev->platform_data;
50
51         if (mmc->slots[0].remux)
52                 mmc->slots[0].remux(dev, slot, power_on);
53
54         /*
55          * Assume we power both OMAP VMMC1 (for CMD, CLK, DAT0..3) and the
56          * card with Vcc regulator (from twl4030 or whatever).  OMAP has both
57          * 1.8V and 3.0V modes, controlled by the PBIAS register.
58          *
59          * In 8-bit modes, OMAP VMMC1A (for DAT4..7) needs a supply, which
60          * is most naturally TWL VSIM; those pins also use PBIAS.
61          *
62          * FIXME handle VMMC1A as needed ...
63          */
64         if (power_on) {
65                 if (cpu_is_omap2430()) {
66                         reg = omap_ctrl_readl(OMAP243X_CONTROL_DEVCONF1);
67                         if ((1 << vdd) >= MMC_VDD_30_31)
68                                 reg |= OMAP243X_MMC1_ACTIVE_OVERWRITE;
69                         else
70                                 reg &= ~OMAP243X_MMC1_ACTIVE_OVERWRITE;
71                         omap_ctrl_writel(reg, OMAP243X_CONTROL_DEVCONF1);
72                 }
73
74                 if (mmc->slots[0].internal_clock) {
75                         reg = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0);
76                         reg |= OMAP2_MMCSDIO1ADPCLKISEL;
77                         omap_ctrl_writel(reg, OMAP2_CONTROL_DEVCONF0);
78                 }
79
80                 reg = omap_ctrl_readl(control_pbias_offset);
81                 if (cpu_is_omap3630()) {
82                         /* Set MMC I/O to 52Mhz */
83                         prog_io = omap_ctrl_readl(OMAP343X_CONTROL_PROG_IO1);
84                         prog_io |= OMAP3630_PRG_SDMMC1_SPEEDCTRL;
85                         omap_ctrl_writel(prog_io, OMAP343X_CONTROL_PROG_IO1);
86                 } else {
87                         reg |= OMAP2_PBIASSPEEDCTRL0;
88                 }
89                 reg &= ~OMAP2_PBIASLITEPWRDNZ0;
90                 omap_ctrl_writel(reg, control_pbias_offset);
91         } else {
92                 reg = omap_ctrl_readl(control_pbias_offset);
93                 reg &= ~OMAP2_PBIASLITEPWRDNZ0;
94                 omap_ctrl_writel(reg, control_pbias_offset);
95         }
96 }
97
98 static void hsmmc1_after_set_reg(struct device *dev, int slot,
99                                  int power_on, int vdd)
100 {
101         u32 reg;
102
103         /* 100ms delay required for PBIAS configuration */
104         msleep(100);
105
106         if (power_on) {
107                 reg = omap_ctrl_readl(control_pbias_offset);
108                 reg |= (OMAP2_PBIASLITEPWRDNZ0 | OMAP2_PBIASSPEEDCTRL0);
109                 if ((1 << vdd) <= MMC_VDD_165_195)
110                         reg &= ~OMAP2_PBIASLITEVMODE0;
111                 else
112                         reg |= OMAP2_PBIASLITEVMODE0;
113                 omap_ctrl_writel(reg, control_pbias_offset);
114         } else {
115                 reg = omap_ctrl_readl(control_pbias_offset);
116                 reg |= (OMAP2_PBIASSPEEDCTRL0 | OMAP2_PBIASLITEPWRDNZ0 |
117                         OMAP2_PBIASLITEVMODE0);
118                 omap_ctrl_writel(reg, control_pbias_offset);
119         }
120 }
121
122 static void hsmmc23_before_set_reg(struct device *dev, int slot,
123                                    int power_on, int vdd)
124 {
125         struct omap_mmc_platform_data *mmc = dev->platform_data;
126
127         if (mmc->slots[0].remux)
128                 mmc->slots[0].remux(dev, slot, power_on);
129
130         if (power_on) {
131                 /* Only MMC2 supports a CLKIN */
132                 if (mmc->slots[0].internal_clock) {
133                         u32 reg;
134
135                         reg = omap_ctrl_readl(control_devconf1_offset);
136                         reg |= OMAP2_MMCSDIO2ADPCLKISEL;
137                         omap_ctrl_writel(reg, control_devconf1_offset);
138                 }
139         }
140 }
141
142 static int nop_mmc_set_power(struct device *dev, int slot, int power_on,
143                                                         int vdd)
144 {
145         return 0;
146 }
147
148 static struct omap_mmc_platform_data *hsmmc_data[OMAP34XX_NR_MMC] __initdata;
149
150 void __init omap2_hsmmc_init(struct omap2_hsmmc_info *controllers)
151 {
152         struct omap2_hsmmc_info *c;
153         int nr_hsmmc = ARRAY_SIZE(hsmmc_data);
154         int i;
155
156         if (cpu_is_omap2430()) {
157                 control_pbias_offset = OMAP243X_CONTROL_PBIAS_LITE;
158                 control_devconf1_offset = OMAP243X_CONTROL_DEVCONF1;
159         } else {
160                 control_pbias_offset = OMAP343X_CONTROL_PBIAS_LITE;
161                 control_devconf1_offset = OMAP343X_CONTROL_DEVCONF1;
162         }
163
164         for (c = controllers; c->mmc; c++) {
165                 struct hsmmc_controller *hc = hsmmc + c->mmc - 1;
166                 struct omap_mmc_platform_data *mmc = hsmmc_data[c->mmc - 1];
167
168                 if (!c->mmc || c->mmc > nr_hsmmc) {
169                         pr_debug("MMC%d: no such controller\n", c->mmc);
170                         continue;
171                 }
172                 if (mmc) {
173                         pr_debug("MMC%d: already configured\n", c->mmc);
174                         continue;
175                 }
176
177                 mmc = kzalloc(sizeof(struct omap_mmc_platform_data),
178                               GFP_KERNEL);
179                 if (!mmc) {
180                         pr_err("Cannot allocate memory for mmc device!\n");
181                         goto done;
182                 }
183
184                 if (c->name)
185                         strncpy(hc->name, c->name, HSMMC_NAME_LEN);
186                 else
187                         snprintf(hc->name, ARRAY_SIZE(hc->name),
188                                 "mmc%islot%i", c->mmc, 1);
189                 mmc->slots[0].name = hc->name;
190                 mmc->nr_slots = 1;
191                 mmc->slots[0].wires = c->wires;
192                 mmc->slots[0].internal_clock = !c->ext_clock;
193                 mmc->dma_mask = 0xffffffff;
194
195                 mmc->get_context_loss_count = hsmmc_get_context_loss;
196
197                 mmc->slots[0].switch_pin = c->gpio_cd;
198                 mmc->slots[0].gpio_wp = c->gpio_wp;
199
200                 mmc->slots[0].remux = c->remux;
201
202                 if (c->cover_only)
203                         mmc->slots[0].cover = 1;
204
205                 if (c->nonremovable)
206                         mmc->slots[0].nonremovable = 1;
207
208                 if (c->power_saving)
209                         mmc->slots[0].power_saving = 1;
210
211                 if (c->no_off)
212                         mmc->slots[0].no_off = 1;
213
214                 if (c->vcc_aux_disable_is_sleep)
215                         mmc->slots[0].vcc_aux_disable_is_sleep = 1;
216
217                 /* NOTE:  MMC slots should have a Vcc regulator set up.
218                  * This may be from a TWL4030-family chip, another
219                  * controllable regulator, or a fixed supply.
220                  *
221                  * temporary HACK: ocr_mask instead of fixed supply
222                  */
223                 mmc->slots[0].ocr_mask = c->ocr_mask;
224
225                 if (cpu_is_omap3517() || cpu_is_omap3505())
226                         mmc->slots[0].set_power = nop_mmc_set_power;
227                 else
228                         mmc->slots[0].features |= HSMMC_HAS_PBIAS;
229
230                 switch (c->mmc) {
231                 case 1:
232                         if (mmc->slots[0].features & HSMMC_HAS_PBIAS) {
233                                 /* on-chip level shifting via PBIAS0/PBIAS1 */
234                                 mmc->slots[0].before_set_reg = hsmmc1_before_set_reg;
235                                 mmc->slots[0].after_set_reg = hsmmc1_after_set_reg;
236                         }
237
238                         /* Omap3630 HSMMC1 supports only 4-bit */
239                         if (cpu_is_omap3630() && c->wires > 4) {
240                                 c->wires = 4;
241                                 mmc->slots[0].wires = c->wires;
242                         }
243                         break;
244                 case 2:
245                         if (c->ext_clock)
246                                 c->transceiver = 1;
247                         if (c->transceiver && c->wires > 4)
248                                 c->wires = 4;
249                         /* FALLTHROUGH */
250                 case 3:
251                         if (mmc->slots[0].features & HSMMC_HAS_PBIAS) {
252                                 /* off-chip level shifting, or none */
253                                 mmc->slots[0].before_set_reg = hsmmc23_before_set_reg;
254                                 mmc->slots[0].after_set_reg = NULL;
255                         }
256                         break;
257                 default:
258                         pr_err("MMC%d configuration not supported!\n", c->mmc);
259                         kfree(mmc);
260                         continue;
261                 }
262                 hsmmc_data[c->mmc - 1] = mmc;
263         }
264
265         omap2_init_mmc(hsmmc_data, OMAP34XX_NR_MMC);
266
267         /* pass the device nodes back to board setup code */
268         for (c = controllers; c->mmc; c++) {
269                 struct omap_mmc_platform_data *mmc = hsmmc_data[c->mmc - 1];
270
271                 if (!c->mmc || c->mmc > nr_hsmmc)
272                         continue;
273                 c->dev = mmc->dev;
274         }
275
276 done:
277         for (i = 0; i < nr_hsmmc; i++)
278                 kfree(hsmmc_data[i]);
279 }
280
281 #endif