g_dnl.c 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * g_dnl.c -- USB Downloader Gadget
  4. *
  5. * Copyright (C) 2012 Samsung Electronics
  6. * Lukasz Majewski <l.majewski@samsung.com>
  7. */
  8. #include <common.h>
  9. #include <malloc.h>
  10. #include <mmc.h>
  11. #include <part.h>
  12. #include <usb.h>
  13. #include <g_dnl.h>
  14. #include <usb_mass_storage.h>
  15. #include <dfu.h>
  16. #include <thor.h>
  17. #include <env_callback.h>
  18. #include "gadget_chips.h"
  19. #include "composite.c"
  20. /*
  21. * One needs to define the following:
  22. * CONFIG_USB_GADGET_VENDOR_NUM
  23. * CONFIG_USB_GADGET_PRODUCT_NUM
  24. * CONFIG_USB_GADGET_MANUFACTURER
  25. * at e.g. ./configs/<board>_defconfig
  26. */
  27. #define STRING_MANUFACTURER 25
  28. #define STRING_PRODUCT 2
  29. /* Index of String Descriptor describing this configuration */
  30. #define STRING_USBDOWN 2
  31. /* Index of String serial */
  32. #define STRING_SERIAL 3
  33. #define MAX_STRING_SERIAL 256
  34. /* Number of supported configurations */
  35. #define CONFIGURATION_NUMBER 1
  36. #define DRIVER_VERSION "usb_dnl 2.0"
  37. static const char product[] = "USB download gadget";
  38. static char g_dnl_serial[MAX_STRING_SERIAL];
  39. static const char manufacturer[] = CONFIG_USB_GADGET_MANUFACTURER;
  40. void g_dnl_set_serialnumber(char *s)
  41. {
  42. memset(g_dnl_serial, 0, MAX_STRING_SERIAL);
  43. strncpy(g_dnl_serial, s, MAX_STRING_SERIAL - 1);
  44. }
  45. static struct usb_device_descriptor device_desc = {
  46. .bLength = sizeof device_desc,
  47. .bDescriptorType = USB_DT_DEVICE,
  48. .bcdUSB = __constant_cpu_to_le16(0x0200),
  49. .bDeviceClass = USB_CLASS_PER_INTERFACE,
  50. .bDeviceSubClass = 0, /*0x02:CDC-modem , 0x00:CDC-serial*/
  51. .idVendor = __constant_cpu_to_le16(CONFIG_USB_GADGET_VENDOR_NUM),
  52. .idProduct = __constant_cpu_to_le16(CONFIG_USB_GADGET_PRODUCT_NUM),
  53. /* .iProduct = DYNAMIC */
  54. /* .iSerialNumber = DYNAMIC */
  55. .bNumConfigurations = 1,
  56. };
  57. /*
  58. * static strings, in UTF-8
  59. * IDs for those strings are assigned dynamically at g_dnl_bind()
  60. */
  61. static struct usb_string g_dnl_string_defs[] = {
  62. {.s = manufacturer},
  63. {.s = product},
  64. {.s = g_dnl_serial},
  65. { } /* end of list */
  66. };
  67. static struct usb_gadget_strings g_dnl_string_tab = {
  68. .language = 0x0409, /* en-us */
  69. .strings = g_dnl_string_defs,
  70. };
  71. static struct usb_gadget_strings *g_dnl_composite_strings[] = {
  72. &g_dnl_string_tab,
  73. NULL,
  74. };
  75. void g_dnl_set_product(const char *s)
  76. {
  77. if (s)
  78. g_dnl_string_defs[1].s = s;
  79. else
  80. g_dnl_string_defs[1].s = product;
  81. }
  82. static int g_dnl_unbind(struct usb_composite_dev *cdev)
  83. {
  84. struct usb_gadget *gadget = cdev->gadget;
  85. debug("%s: calling usb_gadget_disconnect for "
  86. "controller '%s'\n", __func__, gadget->name);
  87. usb_gadget_disconnect(gadget);
  88. return 0;
  89. }
  90. static inline struct g_dnl_bind_callback *g_dnl_bind_callback_first(void)
  91. {
  92. return ll_entry_start(struct g_dnl_bind_callback,
  93. g_dnl_bind_callbacks);
  94. }
  95. static inline struct g_dnl_bind_callback *g_dnl_bind_callback_end(void)
  96. {
  97. return ll_entry_end(struct g_dnl_bind_callback,
  98. g_dnl_bind_callbacks);
  99. }
  100. static int g_dnl_do_config(struct usb_configuration *c)
  101. {
  102. const char *s = c->cdev->driver->name;
  103. struct g_dnl_bind_callback *callback = g_dnl_bind_callback_first();
  104. debug("%s: configuration: 0x%p composite dev: 0x%p\n",
  105. __func__, c, c->cdev);
  106. for (; callback != g_dnl_bind_callback_end(); callback++)
  107. if (!strcmp(s, callback->usb_function_name))
  108. return callback->fptr(c);
  109. return -ENODEV;
  110. }
  111. static int g_dnl_config_register(struct usb_composite_dev *cdev)
  112. {
  113. struct usb_configuration *config;
  114. const char *name = "usb_dnload";
  115. config = memalign(CONFIG_SYS_CACHELINE_SIZE, sizeof(*config));
  116. if (!config)
  117. return -ENOMEM;
  118. memset(config, 0, sizeof(*config));
  119. config->label = name;
  120. config->bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER;
  121. config->bConfigurationValue = CONFIGURATION_NUMBER;
  122. config->iConfiguration = STRING_USBDOWN;
  123. config->bind = g_dnl_do_config;
  124. return usb_add_config(cdev, config);
  125. }
  126. __weak
  127. int board_usb_init(int index, enum usb_init_type init)
  128. {
  129. return 0;
  130. }
  131. __weak
  132. int board_usb_cleanup(int index, enum usb_init_type init)
  133. {
  134. return 0;
  135. }
  136. __weak
  137. int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name)
  138. {
  139. return 0;
  140. }
  141. __weak int g_dnl_get_board_bcd_device_number(int gcnum)
  142. {
  143. return gcnum;
  144. }
  145. __weak int g_dnl_board_usb_cable_connected(void)
  146. {
  147. return -EOPNOTSUPP;
  148. }
  149. static bool g_dnl_detach_request;
  150. bool g_dnl_detach(void)
  151. {
  152. return g_dnl_detach_request;
  153. }
  154. void g_dnl_trigger_detach(void)
  155. {
  156. g_dnl_detach_request = true;
  157. }
  158. void g_dnl_clear_detach(void)
  159. {
  160. g_dnl_detach_request = false;
  161. }
  162. static int g_dnl_get_bcd_device_number(struct usb_composite_dev *cdev)
  163. {
  164. struct usb_gadget *gadget = cdev->gadget;
  165. int gcnum;
  166. gcnum = usb_gadget_controller_number(gadget);
  167. if (gcnum > 0)
  168. gcnum += 0x200;
  169. return g_dnl_get_board_bcd_device_number(gcnum);
  170. }
  171. /**
  172. * Update internal serial number variable when the "serial#" env var changes.
  173. *
  174. * Handle all cases, even when flags == H_PROGRAMMATIC or op == env_op_delete.
  175. */
  176. static int on_serialno(const char *name, const char *value, enum env_op op,
  177. int flags)
  178. {
  179. g_dnl_set_serialnumber((char *)value);
  180. return 0;
  181. }
  182. U_BOOT_ENV_CALLBACK(serialno, on_serialno);
  183. static int g_dnl_bind(struct usb_composite_dev *cdev)
  184. {
  185. struct usb_gadget *gadget = cdev->gadget;
  186. int id, ret;
  187. int gcnum;
  188. debug("%s: gadget: 0x%p cdev: 0x%p\n", __func__, gadget, cdev);
  189. id = usb_string_id(cdev);
  190. if (id < 0)
  191. return id;
  192. g_dnl_string_defs[0].id = id;
  193. device_desc.iManufacturer = id;
  194. id = usb_string_id(cdev);
  195. if (id < 0)
  196. return id;
  197. g_dnl_string_defs[1].id = id;
  198. device_desc.iProduct = id;
  199. g_dnl_bind_fixup(&device_desc, cdev->driver->name);
  200. if (strlen(g_dnl_serial)) {
  201. id = usb_string_id(cdev);
  202. if (id < 0)
  203. return id;
  204. g_dnl_string_defs[2].id = id;
  205. device_desc.iSerialNumber = id;
  206. }
  207. ret = g_dnl_config_register(cdev);
  208. if (ret)
  209. goto error;
  210. gcnum = g_dnl_get_bcd_device_number(cdev);
  211. if (gcnum >= 0)
  212. device_desc.bcdDevice = cpu_to_le16(gcnum);
  213. else {
  214. debug("%s: controller '%s' not recognized\n",
  215. __func__, gadget->name);
  216. device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
  217. }
  218. debug("%s: calling usb_gadget_connect for "
  219. "controller '%s'\n", __func__, gadget->name);
  220. usb_gadget_connect(gadget);
  221. return 0;
  222. error:
  223. g_dnl_unbind(cdev);
  224. return -ENOMEM;
  225. }
  226. static struct usb_composite_driver g_dnl_driver = {
  227. .name = NULL,
  228. .dev = &device_desc,
  229. .strings = g_dnl_composite_strings,
  230. .bind = g_dnl_bind,
  231. .unbind = g_dnl_unbind,
  232. };
  233. /*
  234. * NOTICE:
  235. * Registering via USB function name won't be necessary after rewriting
  236. * g_dnl to support multiple USB functions.
  237. */
  238. int g_dnl_register(const char *name)
  239. {
  240. int ret;
  241. debug("%s: g_dnl_driver.name = %s\n", __func__, name);
  242. g_dnl_driver.name = name;
  243. ret = usb_composite_register(&g_dnl_driver);
  244. if (ret) {
  245. printf("%s: failed!, error: %d\n", __func__, ret);
  246. return ret;
  247. }
  248. return 0;
  249. }
  250. void g_dnl_unregister(void)
  251. {
  252. usb_composite_unregister(&g_dnl_driver);
  253. }