cmd_mmc.c 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322
  1. /*
  2. * (C) Copyright 2003
  3. * Kyle Harris, kharris@nexus-tech.net
  4. *
  5. * See file CREDITS for list of people who contributed to this
  6. * project.
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License as
  10. * published by the Free Software Foundation; either version 2 of
  11. * the License, or (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21. * MA 02111-1307 USA
  22. */
  23. #include <common.h>
  24. #include <command.h>
  25. #include <mmc.h>
  26. static int curr_device = -1;
  27. #ifndef CONFIG_GENERIC_MMC
  28. int do_mmc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  29. {
  30. int dev;
  31. if (argc < 2)
  32. return CMD_RET_USAGE;
  33. if (strcmp(argv[1], "init") == 0) {
  34. if (argc == 2) {
  35. if (curr_device < 0)
  36. dev = 1;
  37. else
  38. dev = curr_device;
  39. } else if (argc == 3) {
  40. dev = (int)simple_strtoul(argv[2], NULL, 10);
  41. } else {
  42. return CMD_RET_USAGE;
  43. }
  44. if (mmc_legacy_init(dev) != 0) {
  45. puts("No MMC card found\n");
  46. return 1;
  47. }
  48. curr_device = dev;
  49. printf("mmc%d is available\n", curr_device);
  50. } else if (strcmp(argv[1], "device") == 0) {
  51. if (argc == 2) {
  52. if (curr_device < 0) {
  53. puts("No MMC device available\n");
  54. return 1;
  55. }
  56. } else if (argc == 3) {
  57. dev = (int)simple_strtoul(argv[2], NULL, 10);
  58. #ifdef CONFIG_SYS_MMC_SET_DEV
  59. if (mmc_set_dev(dev) != 0)
  60. return 1;
  61. #endif
  62. curr_device = dev;
  63. } else {
  64. return CMD_RET_USAGE;
  65. }
  66. printf("mmc%d is current device\n", curr_device);
  67. } else {
  68. return CMD_RET_USAGE;
  69. }
  70. return 0;
  71. }
  72. U_BOOT_CMD(
  73. mmc, 3, 1, do_mmc,
  74. "MMC sub-system",
  75. "init [dev] - init MMC sub system\n"
  76. "mmc device [dev] - show or set current device"
  77. );
  78. #else /* !CONFIG_GENERIC_MMC */
  79. enum mmc_state {
  80. MMC_INVALID,
  81. MMC_READ,
  82. MMC_WRITE,
  83. MMC_ERASE,
  84. };
  85. static void print_mmcinfo(struct mmc *mmc)
  86. {
  87. printf("Device: %s\n", mmc->name);
  88. printf("Manufacturer ID: %x\n", mmc->cid[0] >> 24);
  89. printf("OEM: %x\n", (mmc->cid[0] >> 8) & 0xffff);
  90. printf("Name: %c%c%c%c%c \n", mmc->cid[0] & 0xff,
  91. (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
  92. (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
  93. printf("Tran Speed: %d\n", mmc->tran_speed);
  94. printf("Rd Block Len: %d\n", mmc->read_bl_len);
  95. printf("%s version %d.%d\n", IS_SD(mmc) ? "SD" : "MMC",
  96. (mmc->version >> 4) & 0xf, mmc->version & 0xf);
  97. printf("High Capacity: %s\n", mmc->high_capacity ? "Yes" : "No");
  98. puts("Capacity: ");
  99. print_size(mmc->capacity, "\n");
  100. printf("Bus Width: %d-bit\n", mmc->bus_width);
  101. }
  102. int do_mmcinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  103. {
  104. struct mmc *mmc;
  105. if (curr_device < 0) {
  106. if (get_mmc_num() > 0)
  107. curr_device = 0;
  108. else {
  109. puts("No MMC device available\n");
  110. return 1;
  111. }
  112. }
  113. mmc = find_mmc_device(curr_device);
  114. if (mmc) {
  115. mmc_init(mmc);
  116. print_mmcinfo(mmc);
  117. return 0;
  118. } else {
  119. printf("no mmc device at slot %x\n", curr_device);
  120. return 1;
  121. }
  122. }
  123. U_BOOT_CMD(
  124. mmcinfo, 1, 0, do_mmcinfo,
  125. "display MMC info",
  126. "- dislay info of the current MMC device"
  127. );
  128. int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  129. {
  130. enum mmc_state state;
  131. if (argc < 2)
  132. return CMD_RET_USAGE;
  133. if (curr_device < 0) {
  134. if (get_mmc_num() > 0)
  135. curr_device = 0;
  136. else {
  137. puts("No MMC device available\n");
  138. return 1;
  139. }
  140. }
  141. if (strcmp(argv[1], "rescan") == 0) {
  142. struct mmc *mmc = find_mmc_device(curr_device);
  143. if (!mmc) {
  144. printf("no mmc device at slot %x\n", curr_device);
  145. return 1;
  146. }
  147. mmc->has_init = 0;
  148. if (mmc_init(mmc))
  149. return 1;
  150. else
  151. return 0;
  152. } else if (strncmp(argv[1], "part", 4) == 0) {
  153. block_dev_desc_t *mmc_dev;
  154. struct mmc *mmc = find_mmc_device(curr_device);
  155. if (!mmc) {
  156. printf("no mmc device at slot %x\n", curr_device);
  157. return 1;
  158. }
  159. mmc_init(mmc);
  160. mmc_dev = mmc_get_dev(curr_device);
  161. if (mmc_dev != NULL &&
  162. mmc_dev->type != DEV_TYPE_UNKNOWN) {
  163. print_part(mmc_dev);
  164. return 0;
  165. }
  166. puts("get mmc type error!\n");
  167. return 1;
  168. } else if (strcmp(argv[1], "list") == 0) {
  169. print_mmc_devices('\n');
  170. return 0;
  171. } else if (strcmp(argv[1], "dev") == 0) {
  172. int dev, part = -1;
  173. struct mmc *mmc;
  174. if (argc == 2)
  175. dev = curr_device;
  176. else if (argc == 3)
  177. dev = simple_strtoul(argv[2], NULL, 10);
  178. else if (argc == 4) {
  179. dev = (int)simple_strtoul(argv[2], NULL, 10);
  180. part = (int)simple_strtoul(argv[3], NULL, 10);
  181. if (part > PART_ACCESS_MASK) {
  182. printf("#part_num shouldn't be larger"
  183. " than %d\n", PART_ACCESS_MASK);
  184. return 1;
  185. }
  186. } else
  187. return CMD_RET_USAGE;
  188. mmc = find_mmc_device(dev);
  189. if (!mmc) {
  190. printf("no mmc device at slot %x\n", dev);
  191. return 1;
  192. }
  193. mmc_init(mmc);
  194. if (part != -1) {
  195. int ret;
  196. if (mmc->part_config == MMCPART_NOAVAILABLE) {
  197. printf("Card doesn't support part_switch\n");
  198. return 1;
  199. }
  200. if (part != mmc->part_num) {
  201. ret = mmc_switch_part(dev, part);
  202. if (!ret)
  203. mmc->part_num = part;
  204. printf("switch to partions #%d, %s\n",
  205. part, (!ret) ? "OK" : "ERROR");
  206. }
  207. }
  208. curr_device = dev;
  209. if (mmc->part_config == MMCPART_NOAVAILABLE)
  210. printf("mmc%d is current device\n", curr_device);
  211. else
  212. printf("mmc%d(part %d) is current device\n",
  213. curr_device, mmc->part_num);
  214. return 0;
  215. }
  216. if (strcmp(argv[1], "read") == 0)
  217. state = MMC_READ;
  218. else if (strcmp(argv[1], "write") == 0)
  219. state = MMC_WRITE;
  220. else if (strcmp(argv[1], "erase") == 0)
  221. state = MMC_ERASE;
  222. else
  223. state = MMC_INVALID;
  224. if (state != MMC_INVALID) {
  225. struct mmc *mmc = find_mmc_device(curr_device);
  226. int idx = 2;
  227. u32 blk, cnt, n;
  228. void *addr;
  229. if (state != MMC_ERASE) {
  230. addr = (void *)simple_strtoul(argv[idx], NULL, 16);
  231. ++idx;
  232. } else
  233. addr = 0;
  234. blk = simple_strtoul(argv[idx], NULL, 16);
  235. cnt = simple_strtoul(argv[idx + 1], NULL, 16);
  236. if (!mmc) {
  237. printf("no mmc device at slot %x\n", curr_device);
  238. return 1;
  239. }
  240. printf("\nMMC %s: dev # %d, block # %d, count %d ... ",
  241. argv[1], curr_device, blk, cnt);
  242. mmc_init(mmc);
  243. switch (state) {
  244. case MMC_READ:
  245. n = mmc->block_dev.block_read(curr_device, blk,
  246. cnt, addr);
  247. /* flush cache after read */
  248. flush_cache((ulong)addr, cnt * 512); /* FIXME */
  249. break;
  250. case MMC_WRITE:
  251. n = mmc->block_dev.block_write(curr_device, blk,
  252. cnt, addr);
  253. break;
  254. case MMC_ERASE:
  255. n = mmc->block_dev.block_erase(curr_device, blk, cnt);
  256. break;
  257. default:
  258. BUG();
  259. }
  260. printf("%d blocks %s: %s\n",
  261. n, argv[1], (n == cnt) ? "OK" : "ERROR");
  262. return (n == cnt) ? 0 : 1;
  263. }
  264. return CMD_RET_USAGE;
  265. }
  266. U_BOOT_CMD(
  267. mmc, 6, 1, do_mmcops,
  268. "MMC sub system",
  269. "read addr blk# cnt\n"
  270. "mmc write addr blk# cnt\n"
  271. "mmc erase blk# cnt\n"
  272. "mmc rescan\n"
  273. "mmc part - lists available partition on current mmc device\n"
  274. "mmc dev [dev] [part] - show or set current mmc device [partition]\n"
  275. "mmc list - lists available devices");
  276. #endif