ymodem.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738
  1. /*
  2. * COPYRIGHT (C) 2012, Real-Thread Information Technology Ltd
  3. * All rights reserved
  4. *
  5. * SPDX-License-Identifier: Apache-2.0
  6. *
  7. * Change Logs:
  8. * Date Author Notes
  9. * 2013-04-14 Grissiom initial implementation
  10. * 2019-12-09 Steven Liu add YMODEM send protocol
  11. */
  12. #include <rthw.h>
  13. #include "ymodem.h"
  14. #ifdef YMODEM_USING_CRC_TABLE
  15. static const rt_uint16_t ccitt_table[256] =
  16. {
  17. 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
  18. 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
  19. 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
  20. 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
  21. 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
  22. 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
  23. 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
  24. 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
  25. 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
  26. 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
  27. 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
  28. 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
  29. 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
  30. 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
  31. 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
  32. 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
  33. 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
  34. 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
  35. 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
  36. 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
  37. 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
  38. 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
  39. 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
  40. 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
  41. 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
  42. 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
  43. 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
  44. 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
  45. 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
  46. 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
  47. 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
  48. 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
  49. };
  50. static rt_uint16_t CRC16(unsigned char *q, int len)
  51. {
  52. rt_uint16_t crc = 0;
  53. while (len-- > 0)
  54. crc = (crc << 8) ^ ccitt_table[((crc >> 8) ^ *q++) & 0xff];
  55. return crc;
  56. }
  57. #else
  58. static rt_uint16_t CRC16(unsigned char *q, int len)
  59. {
  60. rt_uint16_t crc;
  61. char i;
  62. crc = 0;
  63. while (--len >= 0)
  64. {
  65. crc = crc ^ (int) * q++ << 8;
  66. i = 8;
  67. do
  68. {
  69. if (crc & 0x8000)
  70. crc = crc << 1 ^ 0x1021;
  71. else
  72. crc = crc << 1;
  73. }
  74. while (--i);
  75. }
  76. return (crc);
  77. }
  78. #endif
  79. rt_uint32_t update_timeout = 0;
  80. // we could only use global varible because we could not use
  81. // rt_device_t->user_data(it is used by the serial driver)...
  82. static struct rym_ctx *_rym_the_ctx;
  83. static rt_err_t _rym_rx_ind(rt_device_t dev, rt_size_t size)
  84. {
  85. return rt_sem_release(&_rym_the_ctx->sem);
  86. }
  87. /* SOH/STX + seq + payload + crc */
  88. #define _RYM_SOH_PKG_SZ (1+2+128+2)
  89. #define _RYM_STX_PKG_SZ (1+2+1024+2)
  90. static enum rym_code _rym_read_code(
  91. struct rym_ctx *ctx,
  92. rt_tick_t timeout)
  93. {
  94. /* Fast path */
  95. if (rt_device_read(ctx->dev, 0, ctx->buf, 1) == 1)
  96. return (enum rym_code)(*ctx->buf);
  97. /* Slow path */
  98. do
  99. {
  100. rt_size_t rsz;
  101. /* No data yet, wait for one */
  102. if (rt_sem_take(&ctx->sem, timeout) != RT_EOK)
  103. return RYM_CODE_NONE;
  104. /* Try to read one */
  105. rsz = rt_device_read(ctx->dev, 0, ctx->buf, 1);
  106. if (rsz == 1)
  107. return (enum rym_code)(*ctx->buf);
  108. }
  109. while (1);
  110. }
  111. /* the caller should at least alloc _RYM_STX_PKG_SZ buffer */
  112. static rt_size_t _rym_read_data(
  113. struct rym_ctx *ctx,
  114. rt_size_t len)
  115. {
  116. /* we should already have had the code */
  117. rt_uint8_t *buf = ctx->buf + 1;
  118. rt_size_t readlen = 0;
  119. do
  120. {
  121. readlen += rt_device_read(ctx->dev,
  122. 0, buf + readlen, len - readlen);
  123. if (readlen >= len)
  124. return readlen;
  125. }
  126. while (rt_sem_take(&ctx->sem, RYM_WAIT_CHR_TICK) == RT_EOK);
  127. return readlen;
  128. }
  129. static rt_err_t _rym_send_packet(
  130. struct rym_ctx *ctx,
  131. enum rym_code code,
  132. rt_uint8_t index)
  133. {
  134. rt_uint16_t send_crc;
  135. rt_uint8_t index_inv = ~index;
  136. rt_size_t writelen = 0;
  137. send_crc = CRC16(ctx->buf + 3, _RYM_SOH_PKG_SZ - 5);
  138. ctx->buf[0] = code;
  139. ctx->buf[1] = index;
  140. ctx->buf[2] = index_inv;
  141. ctx->buf[131] = (rt_uint8_t)(send_crc >> 8);
  142. ctx->buf[132] = (rt_uint8_t)send_crc & 0xff;
  143. do
  144. {
  145. writelen += rt_device_write(ctx->dev, 0, ctx->buf + writelen,
  146. _RYM_SOH_PKG_SZ - writelen);
  147. }
  148. while (writelen < _RYM_SOH_PKG_SZ);
  149. return RT_EOK;
  150. }
  151. static rt_size_t _rym_putchar(struct rym_ctx *ctx, rt_uint8_t code)
  152. {
  153. rt_device_write(ctx->dev, 0, &code, sizeof(code));
  154. return 1;
  155. }
  156. static rt_size_t _rym_getchar(struct rym_ctx *ctx)
  157. {
  158. rt_uint8_t getc_ack;
  159. while (rt_device_read(ctx->dev, 0, &getc_ack, 1) != 1)
  160. {
  161. rt_sem_take(&ctx->sem, RT_WAITING_FOREVER);
  162. }
  163. return getc_ack;
  164. }
  165. static rt_err_t _rym_do_handshake(
  166. struct rym_ctx *ctx,
  167. int tm_sec)
  168. {
  169. enum rym_code code;
  170. rt_size_t i;
  171. rt_uint16_t recv_crc, cal_crc;
  172. rt_size_t data_sz;
  173. rt_tick_t tick;
  174. ctx->stage = RYM_STAGE_ESTABLISHING;
  175. /* send C every second, so the sender could know we are waiting for it. */
  176. for (i = 0; i < tm_sec; i++)
  177. {
  178. _rym_putchar(ctx, RYM_CODE_C);
  179. code = _rym_read_code(ctx,
  180. RYM_CHD_INTV_TICK);
  181. if (code == RYM_CODE_SOH)
  182. {
  183. update_timeout = 0;
  184. data_sz = _RYM_SOH_PKG_SZ;
  185. break;
  186. }
  187. else if (code == RYM_CODE_STX)
  188. {
  189. update_timeout = 0;
  190. data_sz = _RYM_STX_PKG_SZ;
  191. break;
  192. }
  193. //超时重启
  194. update_timeout++;
  195. if(update_timeout==30)
  196. {
  197. rt_hw_cpu_reset();
  198. }
  199. }
  200. if (i == tm_sec)
  201. {
  202. return -RYM_ERR_TMO;
  203. }
  204. /* receive all data */
  205. i = 0;
  206. /* automatic exit after receiving specified length data, timeout: 100ms */
  207. tick = rt_tick_get();
  208. while (rt_tick_get() <= (tick + rt_tick_from_millisecond(100)) && i < (data_sz - 1))
  209. {
  210. i += _rym_read_data(ctx, data_sz - 1);
  211. rt_thread_mdelay(5);
  212. }
  213. if (i != (data_sz - 1))
  214. return -RYM_ERR_DSZ;
  215. /* sanity check */
  216. if (ctx->buf[1] != 0 || ctx->buf[2] != 0xFF)
  217. return -RYM_ERR_SEQ;
  218. recv_crc = (rt_uint16_t)(*(ctx->buf + data_sz - 2) << 8) | *(ctx->buf + data_sz - 1);
  219. cal_crc = CRC16(ctx->buf + 3, data_sz - 5);
  220. if (recv_crc != cal_crc)
  221. return -RYM_ERR_CRC;
  222. /* congratulations, check passed. */
  223. if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_ACK)
  224. return -RYM_ERR_CAN;
  225. return RT_EOK;
  226. }
  227. static rt_err_t _rym_do_send_handshake(
  228. struct rym_ctx *ctx,
  229. int tm_sec)
  230. {
  231. enum rym_code code;
  232. rt_size_t i;
  233. rt_size_t data_sz;
  234. rt_uint8_t index = 0;
  235. rt_uint8_t getc_ack;
  236. ctx->stage = RYM_STAGE_ESTABLISHING;
  237. data_sz = _RYM_SOH_PKG_SZ;
  238. /* receive C every second */
  239. for (i = 0; i < tm_sec; i++)
  240. {
  241. code = _rym_read_code(ctx,
  242. RYM_CHD_INTV_TICK);
  243. if (code == RYM_CODE_C)
  244. {
  245. break;
  246. }
  247. }
  248. if (i == tm_sec)
  249. {
  250. return -RYM_ERR_TMO;
  251. }
  252. /* congratulations, check passed. */
  253. if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_SOH)
  254. return -RYM_ERR_CODE;
  255. code = RYM_CODE_SOH;
  256. _rym_send_packet(ctx, code, index);
  257. rt_device_set_rx_indicate(ctx->dev, _rym_rx_ind);
  258. getc_ack = _rym_getchar(ctx);
  259. if (getc_ack != RYM_CODE_ACK)
  260. {
  261. return -RYM_ERR_ACK;
  262. }
  263. getc_ack = _rym_getchar(ctx);
  264. if (getc_ack != RYM_CODE_C)
  265. {
  266. return -RYM_ERR_ACK;
  267. }
  268. ctx->stage = RYM_STAGE_ESTABLISHED;
  269. return RT_EOK;
  270. }
  271. static rt_err_t _rym_trans_data(
  272. struct rym_ctx *ctx,
  273. rt_size_t data_sz,
  274. enum rym_code *code)
  275. {
  276. const rt_size_t tsz = 2 + data_sz + 2;
  277. rt_uint16_t recv_crc;
  278. /* seq + data + crc */
  279. rt_size_t i = _rym_read_data(ctx, tsz);
  280. if (i != tsz)
  281. return -RYM_ERR_DSZ;
  282. if ((ctx->buf[1] + ctx->buf[2]) != 0xFF)
  283. {
  284. return -RYM_ERR_SEQ;
  285. }
  286. /* As we are sending C continuously, there is a chance that the
  287. * sender(remote) receive an C after sending the first handshake package.
  288. * So the sender will interpret it as NAK and re-send the package. So we
  289. * just ignore it and proceed. */
  290. if (ctx->stage == RYM_STAGE_ESTABLISHED && ctx->buf[1] == 0x00)
  291. {
  292. *code = RYM_CODE_NONE;
  293. return RT_EOK;
  294. }
  295. ctx->stage = RYM_STAGE_TRANSMITTING;
  296. /* sanity check */
  297. recv_crc = (rt_uint16_t)(*(ctx->buf + tsz - 1) << 8) | *(ctx->buf + tsz);
  298. if (recv_crc != CRC16(ctx->buf + 3, data_sz))
  299. return -RYM_ERR_CRC;
  300. /* congratulations, check passed. */
  301. if (ctx->on_data)
  302. *code = ctx->on_data(ctx, ctx->buf + 3, data_sz);
  303. else
  304. *code = RYM_CODE_ACK;
  305. return RT_EOK;
  306. }
  307. static rt_err_t _rym_do_trans(struct rym_ctx *ctx)
  308. {
  309. _rym_putchar(ctx, RYM_CODE_ACK);
  310. _rym_putchar(ctx, RYM_CODE_C);
  311. ctx->stage = RYM_STAGE_ESTABLISHED;
  312. while (1)
  313. {
  314. rt_err_t err;
  315. enum rym_code code;
  316. rt_size_t data_sz, i;
  317. code = _rym_read_code(ctx,
  318. RYM_WAIT_PKG_TICK);
  319. switch (code)
  320. {
  321. case RYM_CODE_SOH:
  322. data_sz = 128;
  323. break;
  324. case RYM_CODE_STX:
  325. data_sz = 1024;
  326. break;
  327. case RYM_CODE_EOT:
  328. return RT_EOK;
  329. default:
  330. return -RYM_ERR_CODE;
  331. };
  332. err = _rym_trans_data(ctx, data_sz, &code);
  333. if (err != RT_EOK)
  334. return err;
  335. switch (code)
  336. {
  337. case RYM_CODE_CAN:
  338. /* the spec require multiple CAN */
  339. for (i = 0; i < RYM_END_SESSION_SEND_CAN_NUM; i++)
  340. {
  341. _rym_putchar(ctx, RYM_CODE_CAN);
  342. }
  343. return -RYM_ERR_CAN;
  344. case RYM_CODE_ACK:
  345. _rym_putchar(ctx, RYM_CODE_ACK);
  346. break;
  347. default:
  348. // wrong code
  349. break;
  350. };
  351. }
  352. }
  353. static rt_err_t _rym_do_send_trans(struct rym_ctx *ctx)
  354. {
  355. ctx->stage = RYM_STAGE_TRANSMITTING;
  356. enum rym_code code;
  357. rt_size_t data_sz;
  358. rt_uint32_t index = 1;
  359. rt_uint8_t getc_ack;
  360. data_sz = _RYM_SOH_PKG_SZ;
  361. while (1)
  362. {
  363. if (ctx->on_data && ctx->on_data(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_SOH)
  364. return -RYM_ERR_CODE;
  365. code = RYM_CODE_SOH;
  366. _rym_send_packet(ctx, code, index);
  367. index++;
  368. rt_device_set_rx_indicate(ctx->dev, _rym_rx_ind);
  369. getc_ack = _rym_getchar(ctx);
  370. if (getc_ack != RYM_CODE_ACK)
  371. {
  372. return -RYM_ERR_ACK;
  373. }
  374. if (ctx->stage == RYM_STAGE_FINISHING)
  375. break;
  376. }
  377. return RT_EOK;
  378. }
  379. static rt_err_t _rym_do_fin(struct rym_ctx *ctx)
  380. {
  381. enum rym_code code;
  382. rt_uint16_t recv_crc;
  383. rt_size_t i;
  384. rt_size_t data_sz;
  385. ctx->stage = RYM_STAGE_FINISHING;
  386. /* we already got one EOT in the caller. invoke the callback if there is
  387. * one. */
  388. if (ctx->on_end)
  389. ctx->on_end(ctx, ctx->buf + 3, 128);
  390. _rym_putchar(ctx, RYM_CODE_NAK);
  391. code = _rym_read_code(ctx, RYM_WAIT_PKG_TICK);
  392. if (code != RYM_CODE_EOT)
  393. return -RYM_ERR_CODE;
  394. _rym_putchar(ctx, RYM_CODE_ACK);
  395. _rym_putchar(ctx, RYM_CODE_C);
  396. code = _rym_read_code(ctx, RYM_WAIT_PKG_TICK);
  397. if (code == RYM_CODE_SOH)
  398. {
  399. data_sz = _RYM_SOH_PKG_SZ;
  400. }
  401. else if (code == RYM_CODE_STX)
  402. {
  403. data_sz = _RYM_STX_PKG_SZ;
  404. }
  405. else
  406. return -RYM_ERR_CODE;
  407. i = _rym_read_data(ctx, _RYM_SOH_PKG_SZ - 1);
  408. if (i != (_RYM_SOH_PKG_SZ - 1))
  409. return -RYM_ERR_DSZ;
  410. /* sanity check
  411. */
  412. if (ctx->buf[1] != 0 || ctx->buf[2] != 0xFF)
  413. return -RYM_ERR_SEQ;
  414. recv_crc = (rt_uint16_t)(*(ctx->buf + _RYM_SOH_PKG_SZ - 2) << 8) | *(ctx->buf + _RYM_SOH_PKG_SZ - 1);
  415. if (recv_crc != CRC16(ctx->buf + 3, _RYM_SOH_PKG_SZ - 5))
  416. return -RYM_ERR_CRC;
  417. /*next file transmission*/
  418. if (ctx->buf[3] != 0)
  419. {
  420. if (ctx->on_begin && ctx->on_begin(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_ACK)
  421. return -RYM_ERR_CAN;
  422. return RT_EOK;
  423. }
  424. /* congratulations, check passed. */
  425. ctx->stage = RYM_STAGE_FINISHED;
  426. /* put the last ACK */
  427. _rym_putchar(ctx, RYM_CODE_ACK);
  428. return RT_EOK;
  429. }
  430. static rt_err_t _rym_do_send_fin(struct rym_ctx *ctx)
  431. {
  432. enum rym_code code;
  433. rt_size_t data_sz;
  434. rt_uint8_t index = 0;
  435. rt_uint8_t getc_ack;
  436. data_sz = _RYM_SOH_PKG_SZ;
  437. rt_device_set_rx_indicate(ctx->dev, _rym_rx_ind);
  438. _rym_putchar(ctx, RYM_CODE_EOT);
  439. getc_ack = _rym_getchar(ctx);
  440. if (getc_ack != RYM_CODE_NAK)
  441. {
  442. return -RYM_ERR_ACK;
  443. }
  444. _rym_putchar(ctx, RYM_CODE_EOT);
  445. getc_ack = _rym_getchar(ctx);
  446. if (getc_ack != RYM_CODE_ACK)
  447. {
  448. return -RYM_ERR_ACK;
  449. }
  450. getc_ack = _rym_getchar(ctx);
  451. if (getc_ack != RYM_CODE_C)
  452. {
  453. return -RYM_ERR_ACK;
  454. }
  455. if (ctx->on_end && ctx->on_end(ctx, ctx->buf + 3, data_sz - 5) != RYM_CODE_SOH)
  456. return -RYM_ERR_CODE;
  457. code = RYM_CODE_SOH;
  458. _rym_send_packet(ctx, code, index);
  459. ctx->stage = RYM_STAGE_FINISHED;
  460. return RT_EOK;
  461. }
  462. static rt_err_t _rym_do_recv(
  463. struct rym_ctx *ctx,
  464. int handshake_timeout)
  465. {
  466. rt_err_t err;
  467. ctx->stage = RYM_STAGE_NONE;
  468. ctx->buf = rt_malloc(_RYM_STX_PKG_SZ);
  469. if (ctx->buf == RT_NULL)
  470. return -RT_ENOMEM;
  471. err = _rym_do_handshake(ctx, handshake_timeout);
  472. if (err != RT_EOK)
  473. {
  474. rt_free(ctx->buf);
  475. return err;
  476. }
  477. while (1)
  478. {
  479. err = _rym_do_trans(ctx);
  480. if (err != RT_EOK)
  481. {
  482. rt_free(ctx->buf);
  483. return err;
  484. }
  485. err = _rym_do_fin(ctx);
  486. if (err != RT_EOK)
  487. {
  488. rt_free(ctx->buf);
  489. return err;
  490. }
  491. if (ctx->stage == RYM_STAGE_FINISHED)
  492. break;
  493. }
  494. rt_free(ctx->buf);
  495. return err;
  496. }
  497. static rt_err_t _rym_do_send(
  498. struct rym_ctx *ctx,
  499. int handshake_timeout)
  500. {
  501. rt_err_t err;
  502. ctx->stage = RYM_STAGE_NONE;
  503. ctx->buf = rt_malloc(_RYM_STX_PKG_SZ);
  504. if (ctx->buf == RT_NULL)
  505. return -RT_ENOMEM;
  506. err = _rym_do_send_handshake(ctx, handshake_timeout);
  507. if (err != RT_EOK)
  508. {
  509. rt_free(ctx->buf);
  510. return err;
  511. }
  512. err = _rym_do_send_trans(ctx);
  513. if (err != RT_EOK)
  514. {
  515. rt_free(ctx->buf);
  516. return err;
  517. }
  518. err = _rym_do_send_fin(ctx);
  519. if (err != RT_EOK)
  520. {
  521. rt_free(ctx->buf);
  522. return err;
  523. }
  524. rt_free(ctx->buf);
  525. return err;
  526. }
  527. rt_err_t rym_recv_on_device(
  528. struct rym_ctx *ctx,
  529. rt_device_t dev,
  530. rt_uint16_t oflag,
  531. rym_callback on_begin,
  532. rym_callback on_data,
  533. rym_callback on_end,
  534. int handshake_timeout)
  535. {
  536. rt_err_t res;
  537. rt_err_t (*odev_rx_ind)(rt_device_t dev, rt_size_t size);
  538. rt_uint16_t odev_flag;
  539. int int_lvl;
  540. RT_ASSERT(_rym_the_ctx == 0);
  541. _rym_the_ctx = ctx;
  542. ctx->on_begin = on_begin;
  543. ctx->on_data = on_data;
  544. ctx->on_end = on_end;
  545. ctx->dev = dev;
  546. rt_sem_init(&ctx->sem, "rymsem", 0, RT_IPC_FLAG_FIFO);
  547. odev_rx_ind = dev->rx_indicate;
  548. /* no data should be received before the device has been fully setted up.
  549. */
  550. int_lvl = rt_hw_interrupt_disable();
  551. rt_device_set_rx_indicate(dev, _rym_rx_ind);
  552. odev_flag = dev->open_flag;
  553. /* make sure the device don't change the content. */
  554. dev->open_flag &= ~RT_DEVICE_FLAG_STREAM;
  555. rt_hw_interrupt_enable(int_lvl);
  556. res = rt_device_open(dev, oflag);
  557. if (res != RT_EOK)
  558. goto __exit;
  559. res = _rym_do_recv(ctx, handshake_timeout);
  560. rt_device_close(dev);
  561. __exit:
  562. /* no rx_ind should be called before the callback has been fully detached.
  563. */
  564. int_lvl = rt_hw_interrupt_disable();
  565. rt_sem_detach(&ctx->sem);
  566. dev->open_flag = odev_flag;
  567. rt_device_set_rx_indicate(dev, odev_rx_ind);
  568. rt_hw_interrupt_enable(int_lvl);
  569. _rym_the_ctx = RT_NULL;
  570. return res;
  571. }
  572. rt_err_t rym_send_on_device(
  573. struct rym_ctx *ctx,
  574. rt_device_t dev,
  575. rt_uint16_t oflag,
  576. rym_callback on_begin,
  577. rym_callback on_data,
  578. rym_callback on_end,
  579. int handshake_timeout)
  580. {
  581. rt_err_t res = 0;
  582. rt_err_t (*odev_rx_ind)(rt_device_t dev, rt_size_t size);
  583. rt_uint16_t odev_flag;
  584. int int_lvl;
  585. RT_ASSERT(_rym_the_ctx == 0);
  586. _rym_the_ctx = ctx;
  587. ctx->on_begin = on_begin;
  588. ctx->on_data = on_data;
  589. ctx->on_end = on_end;
  590. ctx->dev = dev;
  591. rt_sem_init(&ctx->sem, "rymsem", 0, RT_IPC_FLAG_FIFO);
  592. odev_rx_ind = dev->rx_indicate;
  593. /* no data should be received before the device has been fully setted up.
  594. */
  595. int_lvl = rt_hw_interrupt_disable();
  596. rt_device_set_rx_indicate(dev, _rym_rx_ind);
  597. odev_flag = dev->open_flag;
  598. /* make sure the device don't change the content. */
  599. dev->open_flag &= ~RT_DEVICE_FLAG_STREAM;
  600. rt_hw_interrupt_enable(int_lvl);
  601. res = rt_device_open(dev, oflag);
  602. if (res != RT_EOK)
  603. goto __exit;
  604. res = _rym_do_send(ctx, handshake_timeout);
  605. rt_device_close(dev);
  606. __exit:
  607. int_lvl = rt_hw_interrupt_disable();
  608. rt_sem_detach(&ctx->sem);
  609. dev->open_flag = odev_flag;
  610. rt_device_set_rx_indicate(dev, odev_rx_ind);
  611. rt_hw_interrupt_enable(int_lvl);
  612. _rym_the_ctx = RT_NULL;
  613. return res;
  614. }