1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2015 Google, Inc
4 * Copyright 2020 NXP
5 * Written by Simon Glass <sjg@chromium.org>
6 */
7
8 #include <common.h>
9 #include <log.h>
10 #include <mmc.h>
11 #include <dm.h>
12 #include <dm/device-internal.h>
13 #include <dm/device_compat.h>
14 #include <dm/lists.h>
15 #include <linux/compat.h>
16 #include "mmc_private.h"
17
dm_mmc_get_b_max(struct udevice * dev,void * dst,lbaint_t blkcnt)18 int dm_mmc_get_b_max(struct udevice *dev, void *dst, lbaint_t blkcnt)
19 {
20 struct dm_mmc_ops *ops = mmc_get_ops(dev);
21 struct mmc *mmc = mmc_get_mmc_dev(dev);
22
23 if (ops->get_b_max)
24 return ops->get_b_max(dev, dst, blkcnt);
25 else
26 return mmc->cfg->b_max;
27 }
28
mmc_get_b_max(struct mmc * mmc,void * dst,lbaint_t blkcnt)29 int mmc_get_b_max(struct mmc *mmc, void *dst, lbaint_t blkcnt)
30 {
31 return dm_mmc_get_b_max(mmc->dev, dst, blkcnt);
32 }
33
dm_mmc_send_cmd(struct udevice * dev,struct mmc_cmd * cmd,struct mmc_data * data)34 int dm_mmc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
35 struct mmc_data *data)
36 {
37 struct mmc *mmc = mmc_get_mmc_dev(dev);
38 struct dm_mmc_ops *ops = mmc_get_ops(dev);
39 int ret;
40
41 mmmc_trace_before_send(mmc, cmd);
42 if (ops->send_cmd)
43 ret = ops->send_cmd(dev, cmd, data);
44 else
45 ret = -ENOSYS;
46 mmmc_trace_after_send(mmc, cmd, ret);
47
48 return ret;
49 }
50
mmc_send_cmd(struct mmc * mmc,struct mmc_cmd * cmd,struct mmc_data * data)51 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
52 {
53 return dm_mmc_send_cmd(mmc->dev, cmd, data);
54 }
55
dm_mmc_set_ios(struct udevice * dev)56 int dm_mmc_set_ios(struct udevice *dev)
57 {
58 struct dm_mmc_ops *ops = mmc_get_ops(dev);
59
60 if (!ops->set_ios)
61 return -ENOSYS;
62 return ops->set_ios(dev);
63 }
64
mmc_set_ios(struct mmc * mmc)65 int mmc_set_ios(struct mmc *mmc)
66 {
67 return dm_mmc_set_ios(mmc->dev);
68 }
69
dm_mmc_wait_dat0(struct udevice * dev,int state,int timeout_us)70 int dm_mmc_wait_dat0(struct udevice *dev, int state, int timeout_us)
71 {
72 struct dm_mmc_ops *ops = mmc_get_ops(dev);
73
74 if (!ops->wait_dat0)
75 return -ENOSYS;
76 return ops->wait_dat0(dev, state, timeout_us);
77 }
78
mmc_wait_dat0(struct mmc * mmc,int state,int timeout_us)79 int mmc_wait_dat0(struct mmc *mmc, int state, int timeout_us)
80 {
81 return dm_mmc_wait_dat0(mmc->dev, state, timeout_us);
82 }
83
dm_mmc_get_wp(struct udevice * dev)84 int dm_mmc_get_wp(struct udevice *dev)
85 {
86 struct dm_mmc_ops *ops = mmc_get_ops(dev);
87
88 if (!ops->get_wp)
89 return -ENOSYS;
90 return ops->get_wp(dev);
91 }
92
mmc_getwp(struct mmc * mmc)93 int mmc_getwp(struct mmc *mmc)
94 {
95 return dm_mmc_get_wp(mmc->dev);
96 }
97
dm_mmc_get_cd(struct udevice * dev)98 int dm_mmc_get_cd(struct udevice *dev)
99 {
100 struct dm_mmc_ops *ops = mmc_get_ops(dev);
101
102 if (!ops->get_cd)
103 return -ENOSYS;
104 return ops->get_cd(dev);
105 }
106
mmc_getcd(struct mmc * mmc)107 int mmc_getcd(struct mmc *mmc)
108 {
109 return dm_mmc_get_cd(mmc->dev);
110 }
111
112 #ifdef MMC_SUPPORTS_TUNING
dm_mmc_execute_tuning(struct udevice * dev,uint opcode)113 int dm_mmc_execute_tuning(struct udevice *dev, uint opcode)
114 {
115 struct dm_mmc_ops *ops = mmc_get_ops(dev);
116
117 if (!ops->execute_tuning)
118 return -ENOSYS;
119 return ops->execute_tuning(dev, opcode);
120 }
121
mmc_execute_tuning(struct mmc * mmc,uint opcode)122 int mmc_execute_tuning(struct mmc *mmc, uint opcode)
123 {
124 return dm_mmc_execute_tuning(mmc->dev, opcode);
125 }
126 #endif
127
128 #if CONFIG_IS_ENABLED(MMC_HS400_ES_SUPPORT)
dm_mmc_set_enhanced_strobe(struct udevice * dev)129 int dm_mmc_set_enhanced_strobe(struct udevice *dev)
130 {
131 struct dm_mmc_ops *ops = mmc_get_ops(dev);
132
133 if (ops->set_enhanced_strobe)
134 return ops->set_enhanced_strobe(dev);
135
136 return -ENOTSUPP;
137 }
138
mmc_set_enhanced_strobe(struct mmc * mmc)139 int mmc_set_enhanced_strobe(struct mmc *mmc)
140 {
141 return dm_mmc_set_enhanced_strobe(mmc->dev);
142 }
143 #endif
144
dm_mmc_hs400_prepare_ddr(struct udevice * dev)145 int dm_mmc_hs400_prepare_ddr(struct udevice *dev)
146 {
147 struct dm_mmc_ops *ops = mmc_get_ops(dev);
148
149 if (ops->hs400_prepare_ddr)
150 return ops->hs400_prepare_ddr(dev);
151
152 return 0;
153 }
154
mmc_hs400_prepare_ddr(struct mmc * mmc)155 int mmc_hs400_prepare_ddr(struct mmc *mmc)
156 {
157 return dm_mmc_hs400_prepare_ddr(mmc->dev);
158 }
159
dm_mmc_host_power_cycle(struct udevice * dev)160 int dm_mmc_host_power_cycle(struct udevice *dev)
161 {
162 struct dm_mmc_ops *ops = mmc_get_ops(dev);
163
164 if (ops->host_power_cycle)
165 return ops->host_power_cycle(dev);
166 return 0;
167 }
168
mmc_host_power_cycle(struct mmc * mmc)169 int mmc_host_power_cycle(struct mmc *mmc)
170 {
171 return dm_mmc_host_power_cycle(mmc->dev);
172 }
173
dm_mmc_deferred_probe(struct udevice * dev)174 int dm_mmc_deferred_probe(struct udevice *dev)
175 {
176 struct dm_mmc_ops *ops = mmc_get_ops(dev);
177
178 if (ops->deferred_probe)
179 return ops->deferred_probe(dev);
180
181 return 0;
182 }
183
mmc_deferred_probe(struct mmc * mmc)184 int mmc_deferred_probe(struct mmc *mmc)
185 {
186 return dm_mmc_deferred_probe(mmc->dev);
187 }
188
dm_mmc_reinit(struct udevice * dev)189 int dm_mmc_reinit(struct udevice *dev)
190 {
191 struct dm_mmc_ops *ops = mmc_get_ops(dev);
192
193 if (ops->reinit)
194 return ops->reinit(dev);
195
196 return 0;
197 }
198
mmc_reinit(struct mmc * mmc)199 int mmc_reinit(struct mmc *mmc)
200 {
201 return dm_mmc_reinit(mmc->dev);
202 }
203
mmc_of_parse(struct udevice * dev,struct mmc_config * cfg)204 int mmc_of_parse(struct udevice *dev, struct mmc_config *cfg)
205 {
206 int val;
207
208 val = dev_read_u32_default(dev, "bus-width", 1);
209
210 switch (val) {
211 case 0x8:
212 cfg->host_caps |= MMC_MODE_8BIT;
213 /* fall through */
214 case 0x4:
215 cfg->host_caps |= MMC_MODE_4BIT;
216 /* fall through */
217 case 0x1:
218 cfg->host_caps |= MMC_MODE_1BIT;
219 break;
220 default:
221 dev_err(dev, "Invalid \"bus-width\" value %u!\n", val);
222 return -EINVAL;
223 }
224
225 /* f_max is obtained from the optional "max-frequency" property */
226 dev_read_u32(dev, "max-frequency", &cfg->f_max);
227
228 if (dev_read_bool(dev, "cap-sd-highspeed"))
229 cfg->host_caps |= MMC_CAP(SD_HS);
230 if (dev_read_bool(dev, "cap-mmc-highspeed"))
231 cfg->host_caps |= MMC_CAP(MMC_HS) | MMC_CAP(MMC_HS_52);
232 if (dev_read_bool(dev, "sd-uhs-sdr12"))
233 cfg->host_caps |= MMC_CAP(UHS_SDR12);
234 if (dev_read_bool(dev, "sd-uhs-sdr25"))
235 cfg->host_caps |= MMC_CAP(UHS_SDR25);
236 if (dev_read_bool(dev, "sd-uhs-sdr50"))
237 cfg->host_caps |= MMC_CAP(UHS_SDR50);
238 if (dev_read_bool(dev, "sd-uhs-sdr104"))
239 cfg->host_caps |= MMC_CAP(UHS_SDR104);
240 if (dev_read_bool(dev, "sd-uhs-ddr50"))
241 cfg->host_caps |= MMC_CAP(UHS_DDR50);
242 if (dev_read_bool(dev, "mmc-ddr-1_8v"))
243 cfg->host_caps |= MMC_CAP(MMC_DDR_52);
244 if (dev_read_bool(dev, "mmc-ddr-1_2v"))
245 cfg->host_caps |= MMC_CAP(MMC_DDR_52);
246 if (dev_read_bool(dev, "mmc-hs200-1_8v"))
247 cfg->host_caps |= MMC_CAP(MMC_HS_200);
248 if (dev_read_bool(dev, "mmc-hs200-1_2v"))
249 cfg->host_caps |= MMC_CAP(MMC_HS_200);
250 if (dev_read_bool(dev, "mmc-hs400-1_8v"))
251 cfg->host_caps |= MMC_CAP(MMC_HS_400);
252 if (dev_read_bool(dev, "mmc-hs400-1_2v"))
253 cfg->host_caps |= MMC_CAP(MMC_HS_400);
254 if (dev_read_bool(dev, "mmc-hs400-enhanced-strobe"))
255 cfg->host_caps |= MMC_CAP(MMC_HS_400_ES);
256
257 if (dev_read_bool(dev, "non-removable")) {
258 cfg->host_caps |= MMC_CAP_NONREMOVABLE;
259 } else {
260 if (dev_read_bool(dev, "cd-inverted"))
261 cfg->host_caps |= MMC_CAP_CD_ACTIVE_HIGH;
262 if (dev_read_bool(dev, "broken-cd"))
263 cfg->host_caps |= MMC_CAP_NEEDS_POLL;
264 }
265
266 if (dev_read_bool(dev, "no-1-8-v")) {
267 cfg->host_caps &= ~(UHS_CAPS | MMC_MODE_HS200 |
268 MMC_MODE_HS400 | MMC_MODE_HS400_ES);
269 }
270
271 return 0;
272 }
273
mmc_get_mmc_dev(const struct udevice * dev)274 struct mmc *mmc_get_mmc_dev(const struct udevice *dev)
275 {
276 struct mmc_uclass_priv *upriv;
277
278 if (!device_active(dev))
279 return NULL;
280 upriv = dev_get_uclass_priv(dev);
281 return upriv->mmc;
282 }
283
284 #if CONFIG_IS_ENABLED(BLK)
find_mmc_device(int dev_num)285 struct mmc *find_mmc_device(int dev_num)
286 {
287 struct udevice *dev, *mmc_dev;
288 int ret;
289
290 ret = blk_find_device(IF_TYPE_MMC, dev_num, &dev);
291
292 if (ret) {
293 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
294 printf("MMC Device %d not found\n", dev_num);
295 #endif
296 return NULL;
297 }
298
299 mmc_dev = dev_get_parent(dev);
300
301 struct mmc *mmc = mmc_get_mmc_dev(mmc_dev);
302
303 return mmc;
304 }
305
get_mmc_num(void)306 int get_mmc_num(void)
307 {
308 return max((blk_find_max_devnum(IF_TYPE_MMC) + 1), 0);
309 }
310
mmc_get_next_devnum(void)311 int mmc_get_next_devnum(void)
312 {
313 return blk_find_max_devnum(IF_TYPE_MMC);
314 }
315
mmc_get_blk_desc(struct mmc * mmc)316 struct blk_desc *mmc_get_blk_desc(struct mmc *mmc)
317 {
318 struct blk_desc *desc;
319 struct udevice *dev;
320
321 device_find_first_child(mmc->dev, &dev);
322 if (!dev)
323 return NULL;
324 desc = dev_get_uclass_plat(dev);
325
326 return desc;
327 }
328
mmc_do_preinit(void)329 void mmc_do_preinit(void)
330 {
331 struct udevice *dev;
332 struct uclass *uc;
333 int ret;
334
335 ret = uclass_get(UCLASS_MMC, &uc);
336 if (ret)
337 return;
338 uclass_foreach_dev(dev, uc) {
339 struct mmc *m = mmc_get_mmc_dev(dev);
340
341 if (!m)
342 continue;
343 if (m->preinit)
344 mmc_start_init(m);
345 }
346 }
347
348 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
print_mmc_devices(char separator)349 void print_mmc_devices(char separator)
350 {
351 struct udevice *dev;
352 char *mmc_type;
353 bool first = true;
354
355 for (uclass_first_device(UCLASS_MMC, &dev);
356 dev;
357 uclass_next_device(&dev), first = false) {
358 struct mmc *m = mmc_get_mmc_dev(dev);
359
360 if (!first) {
361 printf("%c", separator);
362 if (separator != '\n')
363 puts(" ");
364 }
365 if (m->has_init)
366 mmc_type = IS_SD(m) ? "SD" : "eMMC";
367 else
368 mmc_type = NULL;
369
370 printf("%s: %d", m->cfg->name, mmc_get_blk_desc(m)->devnum);
371 if (mmc_type)
372 printf(" (%s)", mmc_type);
373 }
374
375 printf("\n");
376 }
377
378 #else
print_mmc_devices(char separator)379 void print_mmc_devices(char separator) { }
380 #endif
381
mmc_bind(struct udevice * dev,struct mmc * mmc,const struct mmc_config * cfg)382 int mmc_bind(struct udevice *dev, struct mmc *mmc, const struct mmc_config *cfg)
383 {
384 struct blk_desc *bdesc;
385 struct udevice *bdev;
386 int ret, devnum = -1;
387
388 if (!mmc_get_ops(dev))
389 return -ENOSYS;
390 #ifndef CONFIG_SPL_BUILD
391 /* Use the fixed index with aliase node's index */
392 ret = dev_read_alias_seq(dev, &devnum);
393 debug("%s: alias ret=%d, devnum=%d\n", __func__, ret, devnum);
394 #endif
395
396 ret = blk_create_devicef(dev, "mmc_blk", "blk", IF_TYPE_MMC,
397 devnum, 512, 0, &bdev);
398 if (ret) {
399 debug("Cannot create block device\n");
400 return ret;
401 }
402 bdesc = dev_get_uclass_plat(bdev);
403 mmc->cfg = cfg;
404 mmc->priv = dev;
405
406 /* the following chunk was from mmc_register() */
407
408 /* Setup dsr related values */
409 mmc->dsr_imp = 0;
410 mmc->dsr = 0xffffffff;
411 /* Setup the universal parts of the block interface just once */
412 bdesc->removable = 1;
413
414 /* setup initial part type */
415 bdesc->part_type = cfg->part_type;
416 mmc->dev = dev;
417
418 return 0;
419 }
420
mmc_unbind(struct udevice * dev)421 int mmc_unbind(struct udevice *dev)
422 {
423 struct udevice *bdev;
424
425 device_find_first_child(dev, &bdev);
426 if (bdev) {
427 device_remove(bdev, DM_REMOVE_NORMAL);
428 device_unbind(bdev);
429 }
430
431 return 0;
432 }
433
mmc_select_hwpart(struct udevice * bdev,int hwpart)434 static int mmc_select_hwpart(struct udevice *bdev, int hwpart)
435 {
436 struct udevice *mmc_dev = dev_get_parent(bdev);
437 struct mmc *mmc = mmc_get_mmc_dev(mmc_dev);
438 struct blk_desc *desc = dev_get_uclass_plat(bdev);
439 int ret;
440
441 if (desc->hwpart == hwpart)
442 return 0;
443
444 if (mmc->part_config == MMCPART_NOAVAILABLE)
445 return -EMEDIUMTYPE;
446
447 ret = mmc_switch_part(mmc, hwpart);
448 if (!ret)
449 blkcache_invalidate(desc->if_type, desc->devnum);
450
451 return ret;
452 }
453
mmc_blk_probe(struct udevice * dev)454 static int mmc_blk_probe(struct udevice *dev)
455 {
456 struct udevice *mmc_dev = dev_get_parent(dev);
457 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc_dev);
458 struct mmc *mmc = upriv->mmc;
459 int ret;
460
461 ret = mmc_init(mmc);
462 if (ret) {
463 debug("%s: mmc_init() failed (err=%d)\n", __func__, ret);
464 return ret;
465 }
466
467 return 0;
468 }
469
470 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) || \
471 CONFIG_IS_ENABLED(MMC_HS200_SUPPORT) || \
472 CONFIG_IS_ENABLED(MMC_HS400_SUPPORT)
mmc_blk_remove(struct udevice * dev)473 static int mmc_blk_remove(struct udevice *dev)
474 {
475 struct udevice *mmc_dev = dev_get_parent(dev);
476 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc_dev);
477 struct mmc *mmc = upriv->mmc;
478
479 return mmc_deinit(mmc);
480 }
481 #endif
482
483 static const struct blk_ops mmc_blk_ops = {
484 .read = mmc_bread,
485 #if CONFIG_IS_ENABLED(MMC_WRITE)
486 .write = mmc_bwrite,
487 .erase = mmc_berase,
488 #endif
489 .select_hwpart = mmc_select_hwpart,
490 };
491
492 U_BOOT_DRIVER(mmc_blk) = {
493 .name = "mmc_blk",
494 .id = UCLASS_BLK,
495 .ops = &mmc_blk_ops,
496 .probe = mmc_blk_probe,
497 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) || \
498 CONFIG_IS_ENABLED(MMC_HS200_SUPPORT) || \
499 CONFIG_IS_ENABLED(MMC_HS400_SUPPORT)
500 .remove = mmc_blk_remove,
501 .flags = DM_FLAG_OS_PREPARE,
502 #endif
503 };
504 #endif /* CONFIG_BLK */
505
506
507 UCLASS_DRIVER(mmc) = {
508 .id = UCLASS_MMC,
509 .name = "mmc",
510 .flags = DM_UC_FLAG_SEQ_ALIAS,
511 .per_device_auto = sizeof(struct mmc_uclass_priv),
512 };
513