sata.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227
  1. /*
  2. * Copyright (C) 2000-2005, DENX Software Engineering
  3. * Wolfgang Denk <wd@denx.de>
  4. * Copyright (C) Procsys. All rights reserved.
  5. * Mushtaq Khan <mushtaq_k@procsys.com>
  6. * <mushtaqk_921@yahoo.co.in>
  7. * Copyright (C) 2008 Freescale Semiconductor, Inc.
  8. * Dave Liu <daveliu@freescale.com>
  9. *
  10. * SPDX-License-Identifier: GPL-2.0+
  11. */
  12. #include <common.h>
  13. #include <command.h>
  14. #include <part.h>
  15. #include <sata.h>
  16. static int sata_curr_device = -1;
  17. struct blk_desc sata_dev_desc[CONFIG_SYS_SATA_MAX_DEVICE];
  18. static unsigned long sata_bread(struct blk_desc *block_dev, lbaint_t start,
  19. lbaint_t blkcnt, void *dst)
  20. {
  21. return sata_read(block_dev->devnum, start, blkcnt, dst);
  22. }
  23. static unsigned long sata_bwrite(struct blk_desc *block_dev, lbaint_t start,
  24. lbaint_t blkcnt, const void *buffer)
  25. {
  26. return sata_write(block_dev->devnum, start, blkcnt, buffer);
  27. }
  28. int __sata_initialize(void)
  29. {
  30. int rc;
  31. int i;
  32. for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; i++) {
  33. memset(&sata_dev_desc[i], 0, sizeof(struct blk_desc));
  34. sata_dev_desc[i].if_type = IF_TYPE_SATA;
  35. sata_dev_desc[i].devnum = i;
  36. sata_dev_desc[i].part_type = PART_TYPE_UNKNOWN;
  37. sata_dev_desc[i].type = DEV_TYPE_HARDDISK;
  38. sata_dev_desc[i].lba = 0;
  39. sata_dev_desc[i].blksz = 512;
  40. sata_dev_desc[i].log2blksz = LOG2(sata_dev_desc[i].blksz);
  41. sata_dev_desc[i].block_read = sata_bread;
  42. sata_dev_desc[i].block_write = sata_bwrite;
  43. rc = init_sata(i);
  44. if (!rc) {
  45. rc = scan_sata(i);
  46. if (!rc && (sata_dev_desc[i].lba > 0) &&
  47. (sata_dev_desc[i].blksz > 0))
  48. part_init(&sata_dev_desc[i]);
  49. }
  50. }
  51. sata_curr_device = 0;
  52. return rc;
  53. }
  54. int sata_initialize(void) __attribute__((weak,alias("__sata_initialize")));
  55. __weak int __sata_stop(void)
  56. {
  57. int i, err = 0;
  58. for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; i++)
  59. err |= reset_sata(i);
  60. if (err)
  61. printf("Could not reset some SATA devices\n");
  62. return err;
  63. }
  64. int sata_stop(void) __attribute__((weak, alias("__sata_stop")));
  65. #ifdef CONFIG_PARTITIONS
  66. struct blk_desc *sata_get_dev(int dev)
  67. {
  68. return (dev < CONFIG_SYS_SATA_MAX_DEVICE) ? &sata_dev_desc[dev] : NULL;
  69. }
  70. #endif
  71. static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  72. {
  73. int rc = 0;
  74. if (argc == 2 && strcmp(argv[1], "stop") == 0)
  75. return sata_stop();
  76. if (argc == 2 && strcmp(argv[1], "init") == 0) {
  77. if (sata_curr_device != -1)
  78. sata_stop();
  79. return sata_initialize();
  80. }
  81. /* If the user has not yet run `sata init`, do it now */
  82. if (sata_curr_device == -1)
  83. if (sata_initialize())
  84. return 1;
  85. switch (argc) {
  86. case 0:
  87. case 1:
  88. return CMD_RET_USAGE;
  89. case 2:
  90. if (strncmp(argv[1],"inf", 3) == 0) {
  91. int i;
  92. putc('\n');
  93. for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; ++i) {
  94. if (sata_dev_desc[i].type == DEV_TYPE_UNKNOWN)
  95. continue;
  96. printf ("SATA device %d: ", i);
  97. dev_print(&sata_dev_desc[i]);
  98. }
  99. return 0;
  100. } else if (strncmp(argv[1],"dev", 3) == 0) {
  101. if ((sata_curr_device < 0) || (sata_curr_device >= CONFIG_SYS_SATA_MAX_DEVICE)) {
  102. puts("\nno SATA devices available\n");
  103. return 1;
  104. }
  105. printf("\nSATA device %d: ", sata_curr_device);
  106. dev_print(&sata_dev_desc[sata_curr_device]);
  107. return 0;
  108. } else if (strncmp(argv[1],"part",4) == 0) {
  109. int dev, ok;
  110. for (ok = 0, dev = 0; dev < CONFIG_SYS_SATA_MAX_DEVICE; ++dev) {
  111. if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) {
  112. ++ok;
  113. if (dev)
  114. putc ('\n');
  115. part_print(&sata_dev_desc[dev]);
  116. }
  117. }
  118. if (!ok) {
  119. puts("\nno SATA devices available\n");
  120. rc ++;
  121. }
  122. return rc;
  123. }
  124. return CMD_RET_USAGE;
  125. case 3:
  126. if (strncmp(argv[1], "dev", 3) == 0) {
  127. int dev = (int)simple_strtoul(argv[2], NULL, 10);
  128. printf("\nSATA device %d: ", dev);
  129. if (dev >= CONFIG_SYS_SATA_MAX_DEVICE) {
  130. puts ("unknown device\n");
  131. return 1;
  132. }
  133. dev_print(&sata_dev_desc[dev]);
  134. if (sata_dev_desc[dev].type == DEV_TYPE_UNKNOWN)
  135. return 1;
  136. sata_curr_device = dev;
  137. puts("... is now current device\n");
  138. return 0;
  139. } else if (strncmp(argv[1], "part", 4) == 0) {
  140. int dev = (int)simple_strtoul(argv[2], NULL, 10);
  141. if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) {
  142. part_print(&sata_dev_desc[dev]);
  143. } else {
  144. printf("\nSATA device %d not available\n", dev);
  145. rc = 1;
  146. }
  147. return rc;
  148. }
  149. return CMD_RET_USAGE;
  150. default: /* at least 4 args */
  151. if (strcmp(argv[1], "read") == 0) {
  152. ulong addr = simple_strtoul(argv[2], NULL, 16);
  153. ulong cnt = simple_strtoul(argv[4], NULL, 16);
  154. ulong n;
  155. lbaint_t blk = simple_strtoul(argv[3], NULL, 16);
  156. printf("\nSATA read: device %d block # %ld, count %ld ... ",
  157. sata_curr_device, blk, cnt);
  158. n = sata_read(sata_curr_device, blk, cnt, (u32 *)addr);
  159. /* flush cache after read */
  160. flush_cache(addr, cnt * sata_dev_desc[sata_curr_device].blksz);
  161. printf("%ld blocks read: %s\n",
  162. n, (n==cnt) ? "OK" : "ERROR");
  163. return (n == cnt) ? 0 : 1;
  164. } else if (strcmp(argv[1], "write") == 0) {
  165. ulong addr = simple_strtoul(argv[2], NULL, 16);
  166. ulong cnt = simple_strtoul(argv[4], NULL, 16);
  167. ulong n;
  168. lbaint_t blk = simple_strtoul(argv[3], NULL, 16);
  169. printf("\nSATA write: device %d block # %ld, count %ld ... ",
  170. sata_curr_device, blk, cnt);
  171. n = sata_write(sata_curr_device, blk, cnt, (u32 *)addr);
  172. printf("%ld blocks written: %s\n",
  173. n, (n == cnt) ? "OK" : "ERROR");
  174. return (n == cnt) ? 0 : 1;
  175. } else {
  176. return CMD_RET_USAGE;
  177. }
  178. return rc;
  179. }
  180. }
  181. U_BOOT_CMD(
  182. sata, 5, 1, do_sata,
  183. "SATA sub system",
  184. "init - init SATA sub system\n"
  185. "sata stop - disable SATA sub system\n"
  186. "sata info - show available SATA devices\n"
  187. "sata device [dev] - show or set current device\n"
  188. "sata part [dev] - print partition table\n"
  189. "sata read addr blk# cnt\n"
  190. "sata write addr blk# cnt"
  191. );