blk_legacy.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2016 Google, Inc
  4. * Written by Simon Glass <sjg@chromium.org>
  5. */
  6. #include <common.h>
  7. #include <blk.h>
  8. #include <part.h>
  9. #include <linux/err.h>
  10. struct blk_driver *blk_driver_lookup_type(int if_type)
  11. {
  12. struct blk_driver *drv = ll_entry_start(struct blk_driver, blk_driver);
  13. const int n_ents = ll_entry_count(struct blk_driver, blk_driver);
  14. struct blk_driver *entry;
  15. for (entry = drv; entry != drv + n_ents; entry++) {
  16. if (if_type == entry->if_type)
  17. return entry;
  18. }
  19. /* Not found */
  20. return NULL;
  21. }
  22. static struct blk_driver *blk_driver_lookup_typename(const char *if_typename)
  23. {
  24. struct blk_driver *drv = ll_entry_start(struct blk_driver, blk_driver);
  25. const int n_ents = ll_entry_count(struct blk_driver, blk_driver);
  26. struct blk_driver *entry;
  27. for (entry = drv; entry != drv + n_ents; entry++) {
  28. if (!strcmp(if_typename, entry->if_typename))
  29. return entry;
  30. }
  31. /* Not found */
  32. return NULL;
  33. }
  34. const char *blk_get_if_type_name(enum if_type if_type)
  35. {
  36. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  37. return drv ? drv->if_typename : NULL;
  38. }
  39. /**
  40. * get_desc() - Get the block device descriptor for the given device number
  41. *
  42. * @drv: Legacy block driver
  43. * @devnum: Device number (0 = first)
  44. * @descp: Returns block device descriptor on success
  45. * @return 0 on success, -ENODEV if there is no such device, -ENOSYS if the
  46. * driver does not provide a way to find a device, or other -ve on other
  47. * error.
  48. */
  49. static int get_desc(struct blk_driver *drv, int devnum, struct blk_desc **descp)
  50. {
  51. if (drv->desc) {
  52. if (devnum < 0 || devnum >= drv->max_devs)
  53. return -ENODEV;
  54. *descp = &drv->desc[devnum];
  55. return 0;
  56. }
  57. if (!drv->get_dev)
  58. return -ENOSYS;
  59. return drv->get_dev(devnum, descp);
  60. }
  61. #ifdef CONFIG_HAVE_BLOCK_DEVICE
  62. int blk_list_part(enum if_type if_type)
  63. {
  64. struct blk_driver *drv;
  65. struct blk_desc *desc;
  66. int devnum, ok;
  67. bool first = true;
  68. drv = blk_driver_lookup_type(if_type);
  69. if (!drv)
  70. return -ENOSYS;
  71. for (ok = 0, devnum = 0; devnum < drv->max_devs; ++devnum) {
  72. if (get_desc(drv, devnum, &desc))
  73. continue;
  74. if (desc->part_type != PART_TYPE_UNKNOWN) {
  75. ++ok;
  76. if (!first)
  77. putc('\n');
  78. part_print(desc);
  79. first = false;
  80. }
  81. }
  82. if (!ok)
  83. return -ENODEV;
  84. return 0;
  85. }
  86. int blk_print_part_devnum(enum if_type if_type, int devnum)
  87. {
  88. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  89. struct blk_desc *desc;
  90. int ret;
  91. if (!drv)
  92. return -ENOSYS;
  93. ret = get_desc(drv, devnum, &desc);
  94. if (ret)
  95. return ret;
  96. if (desc->type == DEV_TYPE_UNKNOWN)
  97. return -ENOENT;
  98. part_print(desc);
  99. return 0;
  100. }
  101. void blk_list_devices(enum if_type if_type)
  102. {
  103. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  104. struct blk_desc *desc;
  105. int i;
  106. if (!drv)
  107. return;
  108. for (i = 0; i < drv->max_devs; ++i) {
  109. if (get_desc(drv, i, &desc))
  110. continue;
  111. if (desc->type == DEV_TYPE_UNKNOWN)
  112. continue; /* list only known devices */
  113. printf("Device %d: ", i);
  114. dev_print(desc);
  115. }
  116. }
  117. int blk_print_device_num(enum if_type if_type, int devnum)
  118. {
  119. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  120. struct blk_desc *desc;
  121. int ret;
  122. if (!drv)
  123. return -ENOSYS;
  124. ret = get_desc(drv, devnum, &desc);
  125. if (ret)
  126. return ret;
  127. printf("\n%s device %d: ", drv->if_typename, devnum);
  128. dev_print(desc);
  129. return 0;
  130. }
  131. int blk_show_device(enum if_type if_type, int devnum)
  132. {
  133. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  134. struct blk_desc *desc;
  135. int ret;
  136. if (!drv)
  137. return -ENOSYS;
  138. printf("\nDevice %d: ", devnum);
  139. if (devnum >= drv->max_devs) {
  140. puts("unknown device\n");
  141. return -ENODEV;
  142. }
  143. ret = get_desc(drv, devnum, &desc);
  144. if (ret)
  145. return ret;
  146. dev_print(desc);
  147. if (desc->type == DEV_TYPE_UNKNOWN)
  148. return -ENOENT;
  149. return 0;
  150. }
  151. #endif /* CONFIG_HAVE_BLOCK_DEVICE */
  152. struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
  153. {
  154. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  155. struct blk_desc *desc;
  156. if (!drv)
  157. return NULL;
  158. if (get_desc(drv, devnum, &desc))
  159. return NULL;
  160. return desc;
  161. }
  162. int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
  163. {
  164. struct blk_driver *drv = blk_driver_lookup_type(desc->if_type);
  165. if (!drv)
  166. return -ENOSYS;
  167. if (drv->select_hwpart)
  168. return drv->select_hwpart(desc, hwpart);
  169. return 0;
  170. }
  171. struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
  172. {
  173. struct blk_driver *drv = blk_driver_lookup_typename(if_typename);
  174. struct blk_desc *desc;
  175. if (!drv)
  176. return NULL;
  177. if (get_desc(drv, devnum, &desc))
  178. return NULL;
  179. return desc;
  180. }
  181. ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
  182. lbaint_t blkcnt, void *buffer)
  183. {
  184. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  185. struct blk_desc *desc;
  186. ulong n;
  187. int ret;
  188. if (!drv)
  189. return -ENOSYS;
  190. ret = get_desc(drv, devnum, &desc);
  191. if (ret)
  192. return ret;
  193. n = desc->block_read(desc, start, blkcnt, buffer);
  194. if (IS_ERR_VALUE(n))
  195. return n;
  196. return n;
  197. }
  198. ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
  199. lbaint_t blkcnt, const void *buffer)
  200. {
  201. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  202. struct blk_desc *desc;
  203. int ret;
  204. if (!drv)
  205. return -ENOSYS;
  206. ret = get_desc(drv, devnum, &desc);
  207. if (ret)
  208. return ret;
  209. return desc->block_write(desc, start, blkcnt, buffer);
  210. }
  211. int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
  212. {
  213. struct blk_driver *drv = blk_driver_lookup_type(if_type);
  214. struct blk_desc *desc;
  215. int ret;
  216. if (!drv)
  217. return -ENOSYS;
  218. ret = get_desc(drv, devnum, &desc);
  219. if (ret)
  220. return ret;
  221. return drv->select_hwpart(desc, hwpart);
  222. }