serial.c 44 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547
  1. /*
  2. * Copyright (c) 2006-2023, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2006-03-13 bernard first version
  9. * 2012-05-15 lgnq modified according bernard's implementation.
  10. * 2012-05-28 bernard code cleanup
  11. * 2012-11-23 bernard fix compiler warning.
  12. * 2013-02-20 bernard use RT_SERIAL_RB_BUFSZ to define
  13. * the size of ring buffer.
  14. * 2014-07-10 bernard rewrite serial framework
  15. * 2014-12-31 bernard use open_flag for poll_tx stream mode.
  16. * 2015-05-19 Quintin fix DMA tx mod tx_dma->activated flag !=RT_FALSE BUG
  17. * in open function.
  18. * 2015-11-10 bernard fix the poll rx issue when there is no data.
  19. * 2016-05-10 armink add fifo mode to DMA rx when serial->config.bufsz != 0.
  20. * 2017-01-19 aubr.cool prevent change serial rx bufsz when serial is opened.
  21. * 2017-11-07 JasonJia fix data bits error issue when using tcsetattr.
  22. * 2017-11-15 JasonJia fix poll rx issue when data is full.
  23. * add TCFLSH and FIONREAD support.
  24. * 2018-12-08 Ernest Chen add DMA choice
  25. * 2020-09-14 WillianChan add a line feed to the carriage return character
  26. * when using interrupt tx
  27. * 2020-12-14 Meco Man implement function of setting window's size(TIOCSWINSZ)
  28. * 2021-08-22 Meco Man implement function of getting window's size(TIOCGWINSZ)
  29. * 2023-09-15 xqyjlj perf rt_hw_interrupt_disable/enable
  30. */
  31. #include <rthw.h>
  32. #include <rtthread.h>
  33. #include <rtdevice.h>
  34. #define DBG_TAG "UART"
  35. #define DBG_LVL DBG_INFO
  36. #include <rtdbg.h>
  37. #ifdef RT_USING_POSIX_STDIO
  38. #include <dfs_file.h>
  39. #include <fcntl.h>
  40. #include <unistd.h>
  41. #include <poll.h>
  42. #include <sys/ioctl.h>
  43. #ifdef RT_USING_POSIX_TERMIOS
  44. #include <termios.h>
  45. #endif
  46. /* it's possible the 'getc/putc' is defined by stdio.h in gcc/newlib. */
  47. #ifdef getc
  48. #undef getc
  49. #endif
  50. #ifdef putc
  51. #undef putc
  52. #endif
  53. static rt_err_t serial_fops_rx_ind(rt_device_t dev, rt_size_t size)
  54. {
  55. rt_wqueue_wakeup(&(dev->wait_queue), (void*)POLLIN);
  56. return RT_EOK;
  57. }
  58. /* fops for serial */
  59. static int serial_fops_open(struct dfs_file *fd)
  60. {
  61. rt_err_t ret = 0;
  62. rt_uint16_t flags = 0;
  63. rt_device_t device;
  64. device = (rt_device_t)fd->vnode->data;
  65. RT_ASSERT(device != RT_NULL);
  66. switch (fd->flags & O_ACCMODE)
  67. {
  68. case O_RDONLY:
  69. LOG_D("fops open: O_RDONLY!");
  70. flags = RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_RDONLY;
  71. break;
  72. case O_WRONLY:
  73. LOG_D("fops open: O_WRONLY!");
  74. flags = RT_DEVICE_FLAG_WRONLY;
  75. break;
  76. case O_RDWR:
  77. LOG_D("fops open: O_RDWR!");
  78. flags = RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_RDWR;
  79. break;
  80. default:
  81. LOG_E("fops open: unknown mode - %d!", fd->flags & O_ACCMODE);
  82. break;
  83. }
  84. if ((fd->flags & O_ACCMODE) != O_WRONLY)
  85. rt_device_set_rx_indicate(device, serial_fops_rx_ind);
  86. ret = rt_device_open(device, flags);
  87. if (ret == RT_EOK) return 0;
  88. return ret;
  89. }
  90. static int serial_fops_close(struct dfs_file *fd)
  91. {
  92. rt_device_t device;
  93. device = (rt_device_t)fd->vnode->data;
  94. rt_device_set_rx_indicate(device, RT_NULL);
  95. rt_device_close(device);
  96. return 0;
  97. }
  98. static int serial_fops_ioctl(struct dfs_file *fd, int cmd, void *args)
  99. {
  100. rt_device_t device;
  101. int flags = (int)(rt_base_t)args;
  102. int mask = O_NONBLOCK | O_APPEND;
  103. device = (rt_device_t)fd->vnode->data;
  104. switch (cmd)
  105. {
  106. case FIONREAD:
  107. break;
  108. case FIONWRITE:
  109. break;
  110. case F_SETFL:
  111. flags &= mask;
  112. fd->flags &= ~mask;
  113. fd->flags |= flags;
  114. break;
  115. }
  116. return rt_device_control(device, cmd, args);
  117. }
  118. #ifdef RT_USING_DFS_V2
  119. static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count, off_t *pos)
  120. #else
  121. static ssize_t serial_fops_read(struct dfs_file *fd, void *buf, size_t count)
  122. #endif
  123. {
  124. int size = 0;
  125. rt_device_t device;
  126. int wait_ret;
  127. device = (rt_device_t)fd->vnode->data;
  128. do
  129. {
  130. size = rt_device_read(device, -1, buf, count);
  131. if (size <= 0)
  132. {
  133. if (fd->flags & O_NONBLOCK)
  134. {
  135. size = -EAGAIN;
  136. break;
  137. }
  138. wait_ret = rt_wqueue_wait_interruptible(&(device->wait_queue), 0, RT_WAITING_FOREVER);
  139. if (wait_ret != RT_EOK)
  140. {
  141. break;
  142. }
  143. }
  144. }while (size <= 0);
  145. if (size < 0)
  146. {
  147. size = 0;
  148. }
  149. return size;
  150. }
  151. #ifdef RT_USING_DFS_V2
  152. static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count, off_t *pos)
  153. #else
  154. static ssize_t serial_fops_write(struct dfs_file *fd, const void *buf, size_t count)
  155. #endif
  156. {
  157. rt_device_t device;
  158. device = (rt_device_t)fd->vnode->data;
  159. return rt_device_write(device, -1, buf, count);
  160. }
  161. static int serial_fops_poll(struct dfs_file *fd, struct rt_pollreq *req)
  162. {
  163. int mask = 0;
  164. int flags = 0;
  165. rt_device_t device;
  166. struct rt_serial_device *serial;
  167. device = (rt_device_t)fd->vnode->data;
  168. RT_ASSERT(device != RT_NULL);
  169. serial = (struct rt_serial_device *)device;
  170. /* only support POLLIN */
  171. flags = fd->flags & O_ACCMODE;
  172. if (flags == O_RDONLY || flags == O_RDWR)
  173. {
  174. rt_base_t level;
  175. struct rt_serial_rx_fifo* rx_fifo;
  176. rt_poll_add(&(device->wait_queue), req);
  177. rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx;
  178. level = rt_spin_lock_irqsave(&(serial->spinlock));
  179. if ((rx_fifo->get_index != rx_fifo->put_index) || (rx_fifo->get_index == rx_fifo->put_index && rx_fifo->is_full == RT_TRUE))
  180. mask |= POLLIN;
  181. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  182. }
  183. return mask;
  184. }
  185. static const struct dfs_file_ops _serial_fops =
  186. {
  187. .open = serial_fops_open,
  188. .close = serial_fops_close,
  189. .ioctl = serial_fops_ioctl,
  190. .read = serial_fops_read,
  191. .write = serial_fops_write,
  192. .poll = serial_fops_poll,
  193. };
  194. #endif /* RT_USING_POSIX_STDIO */
  195. /*
  196. * Serial poll routines
  197. */
  198. rt_inline int _serial_poll_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
  199. {
  200. int ch;
  201. int size;
  202. RT_ASSERT(serial != RT_NULL);
  203. size = length;
  204. while (length)
  205. {
  206. ch = serial->ops->getc(serial);
  207. if (ch == -1) break;
  208. *data = ch;
  209. data ++; length --;
  210. if(serial->parent.open_flag & RT_DEVICE_FLAG_STREAM)
  211. {
  212. if (ch == '\n') break;
  213. }
  214. }
  215. return size - length;
  216. }
  217. rt_inline int _serial_poll_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
  218. {
  219. int size;
  220. RT_ASSERT(serial != RT_NULL);
  221. size = length;
  222. while (length)
  223. {
  224. /*
  225. * to be polite with serial console add a line feed
  226. * to the carriage return character
  227. */
  228. if (*data == '\n' && (serial->parent.open_flag & RT_DEVICE_FLAG_STREAM))
  229. {
  230. serial->ops->putc(serial, '\r');
  231. }
  232. serial->ops->putc(serial, *data);
  233. ++ data;
  234. -- length;
  235. }
  236. return size - length;
  237. }
  238. /*
  239. * Serial interrupt routines
  240. */
  241. rt_inline int _serial_int_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
  242. {
  243. int size;
  244. struct rt_serial_rx_fifo* rx_fifo;
  245. RT_ASSERT(serial != RT_NULL);
  246. size = length;
  247. rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx;
  248. RT_ASSERT(rx_fifo != RT_NULL);
  249. /* read from software FIFO */
  250. while (length)
  251. {
  252. int ch;
  253. rt_base_t level;
  254. /* disable interrupt */
  255. level = rt_spin_lock_irqsave(&(serial->spinlock));
  256. /* there's no data: */
  257. if ((rx_fifo->get_index == rx_fifo->put_index) && (rx_fifo->is_full == RT_FALSE))
  258. {
  259. /* no data, enable interrupt and break out */
  260. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  261. break;
  262. }
  263. /* otherwise there's the data: */
  264. ch = rx_fifo->buffer[rx_fifo->get_index];
  265. rx_fifo->get_index += 1;
  266. if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;
  267. if (rx_fifo->is_full == RT_TRUE)
  268. {
  269. rx_fifo->is_full = RT_FALSE;
  270. }
  271. /* enable interrupt */
  272. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  273. *data = ch & 0xff;
  274. data ++; length --;
  275. }
  276. return size - length;
  277. }
  278. rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
  279. {
  280. int size;
  281. struct rt_serial_tx_fifo *tx;
  282. RT_ASSERT(serial != RT_NULL);
  283. size = length;
  284. tx = (struct rt_serial_tx_fifo*) serial->serial_tx;
  285. RT_ASSERT(tx != RT_NULL);
  286. while (length)
  287. {
  288. /*
  289. * to be polite with serial console add a line feed
  290. * to the carriage return character
  291. */
  292. if (*data == '\n' && (serial->parent.open_flag & RT_DEVICE_FLAG_STREAM))
  293. {
  294. if (serial->ops->putc(serial, '\r') == -1)
  295. {
  296. rt_completion_wait(&(tx->completion), RT_WAITING_FOREVER);
  297. continue;
  298. }
  299. }
  300. while (serial->ops->putc(serial, *(char*)data) == -1)
  301. {
  302. rt_completion_wait(&(tx->completion), RT_WAITING_FOREVER);
  303. }
  304. data ++; length --;
  305. }
  306. return size - length;
  307. }
  308. static void _serial_check_buffer_size(void)
  309. {
  310. static rt_bool_t already_output = RT_FALSE;
  311. if (already_output == RT_FALSE)
  312. {
  313. #if !defined(RT_USING_ULOG) || defined(ULOG_USING_ISR_LOG)
  314. LOG_W("Warning: There is no enough buffer for saving data,"
  315. " please increase the RT_SERIAL_RB_BUFSZ option.");
  316. #endif
  317. already_output = RT_TRUE;
  318. }
  319. }
  320. #if defined(RT_USING_POSIX_STDIO) || defined(RT_SERIAL_USING_DMA)
  321. static rt_ssize_t _serial_fifo_calc_recved_len(struct rt_serial_device *serial)
  322. {
  323. struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
  324. RT_ASSERT(rx_fifo != RT_NULL);
  325. if (rx_fifo->put_index == rx_fifo->get_index)
  326. {
  327. return (rx_fifo->is_full == RT_FALSE ? 0 : serial->config.bufsz);
  328. }
  329. else
  330. {
  331. if (rx_fifo->put_index > rx_fifo->get_index)
  332. {
  333. return rx_fifo->put_index - rx_fifo->get_index;
  334. }
  335. else
  336. {
  337. return serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index);
  338. }
  339. }
  340. }
  341. #endif /* RT_USING_POSIX_STDIO || RT_SERIAL_USING_DMA */
  342. #ifdef RT_SERIAL_USING_DMA
  343. /**
  344. * Calculate DMA received data length.
  345. *
  346. * @param serial serial device
  347. *
  348. * @return length
  349. */
  350. static rt_ssize_t rt_dma_calc_recved_len(struct rt_serial_device *serial)
  351. {
  352. return _serial_fifo_calc_recved_len(serial);
  353. }
  354. /**
  355. * Read data finish by DMA mode then update the get index for receive fifo.
  356. *
  357. * @param serial serial device
  358. * @param len get data length for this operate
  359. */
  360. static void rt_dma_recv_update_get_index(struct rt_serial_device *serial, rt_size_t len)
  361. {
  362. struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
  363. RT_ASSERT(rx_fifo != RT_NULL);
  364. RT_ASSERT(len <= rt_dma_calc_recved_len(serial));
  365. if (rx_fifo->is_full && len != 0) rx_fifo->is_full = RT_FALSE;
  366. rx_fifo->get_index += (rt_uint16_t)len;
  367. if (rx_fifo->get_index >= serial->config.bufsz)
  368. {
  369. rx_fifo->get_index %= serial->config.bufsz;
  370. }
  371. }
  372. /**
  373. * DMA received finish then update put index for receive fifo.
  374. *
  375. * @param serial serial device
  376. * @param len received length for this transmit
  377. */
  378. static void rt_dma_recv_update_put_index(struct rt_serial_device *serial, rt_size_t len)
  379. {
  380. struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
  381. RT_ASSERT(rx_fifo != RT_NULL);
  382. if (rx_fifo->get_index <= rx_fifo->put_index)
  383. {
  384. rx_fifo->put_index += (rt_uint16_t)len;
  385. /* beyond the fifo end */
  386. if (rx_fifo->put_index >= serial->config.bufsz)
  387. {
  388. rx_fifo->put_index %= serial->config.bufsz;
  389. /* force overwrite get index */
  390. if (rx_fifo->put_index >= rx_fifo->get_index)
  391. {
  392. rx_fifo->is_full = RT_TRUE;
  393. }
  394. }
  395. }
  396. else
  397. {
  398. rx_fifo->put_index += (rt_uint16_t)len;
  399. if (rx_fifo->put_index >= rx_fifo->get_index)
  400. {
  401. /* beyond the fifo end */
  402. if (rx_fifo->put_index >= serial->config.bufsz)
  403. {
  404. rx_fifo->put_index %= serial->config.bufsz;
  405. }
  406. /* force overwrite get index */
  407. rx_fifo->is_full = RT_TRUE;
  408. }
  409. }
  410. if(rx_fifo->is_full == RT_TRUE)
  411. {
  412. _serial_check_buffer_size();
  413. rx_fifo->get_index = rx_fifo->put_index;
  414. }
  415. }
  416. /*
  417. * Serial DMA routines
  418. */
  419. rt_inline int _serial_dma_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
  420. {
  421. rt_base_t level;
  422. RT_ASSERT((serial != RT_NULL) && (data != RT_NULL));
  423. level = rt_spin_lock_irqsave(&(serial->spinlock));
  424. if (serial->config.bufsz == 0)
  425. {
  426. int result = RT_EOK;
  427. struct rt_serial_rx_dma *rx_dma;
  428. rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
  429. RT_ASSERT(rx_dma != RT_NULL);
  430. if (rx_dma->activated != RT_TRUE)
  431. {
  432. rx_dma->activated = RT_TRUE;
  433. RT_ASSERT(serial->ops->dma_transmit != RT_NULL);
  434. serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);
  435. }
  436. else result = -RT_EBUSY;
  437. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  438. if (result == RT_EOK) return length;
  439. rt_set_errno(result);
  440. return 0;
  441. }
  442. else
  443. {
  444. struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
  445. rt_size_t recv_len = 0, fifo_recved_len = rt_dma_calc_recved_len(serial);
  446. RT_ASSERT(rx_fifo != RT_NULL);
  447. if (length < (int)fifo_recved_len)
  448. recv_len = length;
  449. else
  450. recv_len = fifo_recved_len;
  451. if (rx_fifo->get_index + recv_len < serial->config.bufsz)
  452. rt_memcpy(data, rx_fifo->buffer + rx_fifo->get_index, recv_len);
  453. else
  454. {
  455. rt_memcpy(data, rx_fifo->buffer + rx_fifo->get_index,
  456. serial->config.bufsz - rx_fifo->get_index);
  457. rt_memcpy(data + serial->config.bufsz - rx_fifo->get_index, rx_fifo->buffer,
  458. recv_len + rx_fifo->get_index - serial->config.bufsz);
  459. }
  460. rt_dma_recv_update_get_index(serial, recv_len);
  461. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  462. return recv_len;
  463. }
  464. }
  465. rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
  466. {
  467. rt_base_t level;
  468. rt_err_t result;
  469. struct rt_serial_tx_dma *tx_dma;
  470. tx_dma = (struct rt_serial_tx_dma*)(serial->serial_tx);
  471. result = rt_data_queue_push(&(tx_dma->data_queue), data, length, RT_WAITING_FOREVER);
  472. if (result == RT_EOK)
  473. {
  474. level = rt_spin_lock_irqsave(&(serial->spinlock));
  475. if (tx_dma->activated != RT_TRUE)
  476. {
  477. tx_dma->activated = RT_TRUE;
  478. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  479. /* make a DMA transfer */
  480. serial->ops->dma_transmit(serial, (rt_uint8_t *)data, length, RT_SERIAL_DMA_TX);
  481. }
  482. else
  483. {
  484. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  485. }
  486. return length;
  487. }
  488. else
  489. {
  490. rt_set_errno(result);
  491. return 0;
  492. }
  493. }
  494. #endif /* RT_SERIAL_USING_DMA */
  495. /* RT-Thread Device Interface */
  496. /*
  497. * This function initializes serial device.
  498. */
  499. static rt_err_t rt_serial_init(struct rt_device *dev)
  500. {
  501. rt_err_t result = RT_EOK;
  502. struct rt_serial_device *serial;
  503. RT_ASSERT(dev != RT_NULL);
  504. serial = (struct rt_serial_device *)dev;
  505. /* initialize rx/tx */
  506. serial->serial_rx = RT_NULL;
  507. serial->serial_tx = RT_NULL;
  508. rt_memset(&serial->rx_notify, 0, sizeof(struct rt_device_notify));
  509. /* apply configuration */
  510. if (serial->ops->configure)
  511. result = serial->ops->configure(serial, &serial->config);
  512. return result;
  513. }
  514. static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
  515. {
  516. rt_uint16_t stream_flag = 0;
  517. struct rt_serial_device *serial;
  518. RT_ASSERT(dev != RT_NULL);
  519. serial = (struct rt_serial_device *)dev;
  520. LOG_D("open serial device: 0x%08x with open flag: 0x%04x",
  521. dev, oflag);
  522. /* check device flag with the open flag */
  523. if ((oflag & RT_DEVICE_FLAG_DMA_RX) && !(dev->flag & RT_DEVICE_FLAG_DMA_RX))
  524. return -RT_EIO;
  525. if ((oflag & RT_DEVICE_FLAG_DMA_TX) && !(dev->flag & RT_DEVICE_FLAG_DMA_TX))
  526. return -RT_EIO;
  527. if ((oflag & RT_DEVICE_FLAG_INT_RX) && !(dev->flag & RT_DEVICE_FLAG_INT_RX))
  528. return -RT_EIO;
  529. if ((oflag & RT_DEVICE_FLAG_INT_TX) && !(dev->flag & RT_DEVICE_FLAG_INT_TX))
  530. return -RT_EIO;
  531. /* keep steam flag */
  532. if ((oflag & RT_DEVICE_FLAG_STREAM) || (dev->open_flag & RT_DEVICE_FLAG_STREAM))
  533. stream_flag = RT_DEVICE_FLAG_STREAM;
  534. /* get open flags */
  535. dev->open_flag = oflag & 0xff;
  536. #ifdef RT_USING_PINCTRL
  537. /* initialize iomux in DM */
  538. rt_pin_ctrl_confs_apply_by_name(dev, RT_NULL);
  539. #endif
  540. /* initialize the Rx/Tx structure according to open flag */
  541. if (serial->serial_rx == RT_NULL)
  542. {
  543. if (oflag & RT_DEVICE_FLAG_INT_RX)
  544. {
  545. struct rt_serial_rx_fifo* rx_fifo;
  546. rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
  547. serial->config.bufsz);
  548. RT_ASSERT(rx_fifo != RT_NULL);
  549. rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
  550. rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
  551. rx_fifo->put_index = 0;
  552. rx_fifo->get_index = 0;
  553. rx_fifo->is_full = RT_FALSE;
  554. serial->serial_rx = rx_fifo;
  555. dev->open_flag |= RT_DEVICE_FLAG_INT_RX;
  556. /* configure low level device */
  557. serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_RX);
  558. }
  559. #ifdef RT_SERIAL_USING_DMA
  560. else if (oflag & RT_DEVICE_FLAG_DMA_RX)
  561. {
  562. if (serial->config.bufsz == 0) {
  563. struct rt_serial_rx_dma* rx_dma;
  564. rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma));
  565. RT_ASSERT(rx_dma != RT_NULL);
  566. rx_dma->activated = RT_FALSE;
  567. serial->serial_rx = rx_dma;
  568. } else {
  569. struct rt_serial_rx_fifo* rx_fifo;
  570. rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
  571. serial->config.bufsz);
  572. RT_ASSERT(rx_fifo != RT_NULL);
  573. rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
  574. rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
  575. rx_fifo->put_index = 0;
  576. rx_fifo->get_index = 0;
  577. rx_fifo->is_full = RT_FALSE;
  578. serial->serial_rx = rx_fifo;
  579. /* configure fifo address and length to low level device */
  580. serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *) RT_DEVICE_FLAG_DMA_RX);
  581. }
  582. dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
  583. }
  584. #endif /* RT_SERIAL_USING_DMA */
  585. else
  586. {
  587. serial->serial_rx = RT_NULL;
  588. }
  589. }
  590. else
  591. {
  592. if (oflag & RT_DEVICE_FLAG_INT_RX)
  593. dev->open_flag |= RT_DEVICE_FLAG_INT_RX;
  594. #ifdef RT_SERIAL_USING_DMA
  595. else if (oflag & RT_DEVICE_FLAG_DMA_RX)
  596. dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
  597. #endif /* RT_SERIAL_USING_DMA */
  598. }
  599. if (serial->serial_tx == RT_NULL)
  600. {
  601. if (oflag & RT_DEVICE_FLAG_INT_TX)
  602. {
  603. struct rt_serial_tx_fifo *tx_fifo;
  604. tx_fifo = (struct rt_serial_tx_fifo*) rt_malloc(sizeof(struct rt_serial_tx_fifo));
  605. RT_ASSERT(tx_fifo != RT_NULL);
  606. rt_completion_init(&(tx_fifo->completion));
  607. serial->serial_tx = tx_fifo;
  608. dev->open_flag |= RT_DEVICE_FLAG_INT_TX;
  609. /* configure low level device */
  610. serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_TX);
  611. }
  612. #ifdef RT_SERIAL_USING_DMA
  613. else if (oflag & RT_DEVICE_FLAG_DMA_TX)
  614. {
  615. struct rt_serial_tx_dma* tx_dma;
  616. tx_dma = (struct rt_serial_tx_dma*) rt_malloc (sizeof(struct rt_serial_tx_dma));
  617. RT_ASSERT(tx_dma != RT_NULL);
  618. tx_dma->activated = RT_FALSE;
  619. rt_data_queue_init(&(tx_dma->data_queue), 8, 4, RT_NULL);
  620. serial->serial_tx = tx_dma;
  621. dev->open_flag |= RT_DEVICE_FLAG_DMA_TX;
  622. /* configure low level device */
  623. serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *)RT_DEVICE_FLAG_DMA_TX);
  624. }
  625. #endif /* RT_SERIAL_USING_DMA */
  626. else
  627. {
  628. serial->serial_tx = RT_NULL;
  629. }
  630. }
  631. else
  632. {
  633. if (oflag & RT_DEVICE_FLAG_INT_TX)
  634. dev->open_flag |= RT_DEVICE_FLAG_INT_TX;
  635. #ifdef RT_SERIAL_USING_DMA
  636. else if (oflag & RT_DEVICE_FLAG_DMA_TX)
  637. dev->open_flag |= RT_DEVICE_FLAG_DMA_TX;
  638. #endif /* RT_SERIAL_USING_DMA */
  639. }
  640. /* set stream flag */
  641. dev->open_flag |= stream_flag;
  642. return RT_EOK;
  643. }
  644. static rt_err_t rt_serial_close(struct rt_device *dev)
  645. {
  646. struct rt_serial_device *serial;
  647. RT_ASSERT(dev != RT_NULL);
  648. serial = (struct rt_serial_device *)dev;
  649. /* this device has more reference count */
  650. if (dev->ref_count > 1) return RT_EOK;
  651. if (dev->open_flag & RT_DEVICE_FLAG_INT_RX)
  652. {
  653. struct rt_serial_rx_fifo* rx_fifo;
  654. /* configure low level device */
  655. serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_RX);
  656. dev->open_flag &= ~RT_DEVICE_FLAG_INT_RX;
  657. rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
  658. RT_ASSERT(rx_fifo != RT_NULL);
  659. rt_free(rx_fifo);
  660. serial->serial_rx = RT_NULL;
  661. }
  662. #ifdef RT_SERIAL_USING_DMA
  663. else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
  664. {
  665. /* configure low level device */
  666. serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void *) RT_DEVICE_FLAG_DMA_RX);
  667. dev->open_flag &= ~RT_DEVICE_FLAG_DMA_RX;
  668. if (serial->config.bufsz == 0)
  669. {
  670. struct rt_serial_rx_dma* rx_dma;
  671. rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
  672. RT_ASSERT(rx_dma != RT_NULL);
  673. rt_free(rx_dma);
  674. }
  675. else
  676. {
  677. struct rt_serial_rx_fifo* rx_fifo;
  678. rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
  679. RT_ASSERT(rx_fifo != RT_NULL);
  680. rt_free(rx_fifo);
  681. }
  682. serial->serial_rx = RT_NULL;
  683. }
  684. #endif /* RT_SERIAL_USING_DMA */
  685. if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
  686. {
  687. struct rt_serial_tx_fifo* tx_fifo;
  688. serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void*)RT_DEVICE_FLAG_INT_TX);
  689. dev->open_flag &= ~RT_DEVICE_FLAG_INT_TX;
  690. tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_tx;
  691. RT_ASSERT(tx_fifo != RT_NULL);
  692. rt_free(tx_fifo);
  693. serial->serial_tx = RT_NULL;
  694. /* configure low level device */
  695. }
  696. #ifdef RT_SERIAL_USING_DMA
  697. else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX)
  698. {
  699. struct rt_serial_tx_dma* tx_dma;
  700. /* configure low level device */
  701. serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void *) RT_DEVICE_FLAG_DMA_TX);
  702. dev->open_flag &= ~RT_DEVICE_FLAG_DMA_TX;
  703. tx_dma = (struct rt_serial_tx_dma*)serial->serial_tx;
  704. RT_ASSERT(tx_dma != RT_NULL);
  705. rt_data_queue_deinit(&(tx_dma->data_queue));
  706. rt_free(tx_dma);
  707. serial->serial_tx = RT_NULL;
  708. }
  709. #endif /* RT_SERIAL_USING_DMA */
  710. serial->ops->control(serial, RT_DEVICE_CTRL_CLOSE, RT_NULL);
  711. dev->flag &= ~RT_DEVICE_FLAG_ACTIVATED;
  712. return RT_EOK;
  713. }
  714. static rt_ssize_t rt_serial_read(struct rt_device *dev,
  715. rt_off_t pos,
  716. void *buffer,
  717. rt_size_t size)
  718. {
  719. struct rt_serial_device *serial;
  720. RT_ASSERT(dev != RT_NULL);
  721. if (size == 0) return 0;
  722. serial = (struct rt_serial_device *)dev;
  723. if (dev->open_flag & RT_DEVICE_FLAG_INT_RX)
  724. {
  725. return _serial_int_rx(serial, (rt_uint8_t *)buffer, size);
  726. }
  727. #ifdef RT_SERIAL_USING_DMA
  728. else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
  729. {
  730. return _serial_dma_rx(serial, (rt_uint8_t *)buffer, size);
  731. }
  732. #endif /* RT_SERIAL_USING_DMA */
  733. return _serial_poll_rx(serial, (rt_uint8_t *)buffer, size);
  734. }
  735. static rt_ssize_t rt_serial_write(struct rt_device *dev,
  736. rt_off_t pos,
  737. const void *buffer,
  738. rt_size_t size)
  739. {
  740. struct rt_serial_device *serial;
  741. RT_ASSERT(dev != RT_NULL);
  742. if (size == 0) return 0;
  743. serial = (struct rt_serial_device *)dev;
  744. if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
  745. {
  746. return _serial_int_tx(serial, (const rt_uint8_t *)buffer, size);
  747. }
  748. #ifdef RT_SERIAL_USING_DMA
  749. else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX)
  750. {
  751. return _serial_dma_tx(serial, (const rt_uint8_t *)buffer, size);
  752. }
  753. #endif /* RT_SERIAL_USING_DMA */
  754. else
  755. {
  756. return _serial_poll_tx(serial, (const rt_uint8_t *)buffer, size);
  757. }
  758. }
  759. #if defined(RT_USING_POSIX_TERMIOS)
  760. struct speed_baudrate_item
  761. {
  762. speed_t speed;
  763. int baudrate;
  764. };
  765. static const struct speed_baudrate_item _tbl[] =
  766. {
  767. {B2400, BAUD_RATE_2400},
  768. {B4800, BAUD_RATE_4800},
  769. {B9600, BAUD_RATE_9600},
  770. {B19200, BAUD_RATE_19200},
  771. {B38400, BAUD_RATE_38400},
  772. {B57600, BAUD_RATE_57600},
  773. {B115200, BAUD_RATE_115200},
  774. {B230400, BAUD_RATE_230400},
  775. {B460800, BAUD_RATE_460800},
  776. {B500000, BAUD_RATE_500000},
  777. {B576000, BAUD_RATE_576000},
  778. {B921600, BAUD_RATE_921600},
  779. {B1000000, BAUD_RATE_1000000},
  780. {B1152000, BAUD_RATE_1152000},
  781. {B1500000, BAUD_RATE_1500000},
  782. {B2000000, BAUD_RATE_2000000},
  783. {B2500000, BAUD_RATE_2500000},
  784. {B3000000, BAUD_RATE_3000000},
  785. {B3500000, BAUD_RATE_3500000},
  786. {B4000000, BAUD_RATE_4000000},
  787. };
  788. static speed_t _get_speed(int baudrate)
  789. {
  790. size_t index;
  791. for (index = 0; index < sizeof(_tbl)/sizeof(_tbl[0]); index ++)
  792. {
  793. if (_tbl[index].baudrate == baudrate)
  794. return _tbl[index].speed;
  795. }
  796. return B0;
  797. }
  798. static int _get_baudrate(speed_t speed)
  799. {
  800. size_t index;
  801. for (index = 0; index < sizeof(_tbl)/sizeof(_tbl[0]); index ++)
  802. {
  803. if (_tbl[index].speed == speed)
  804. return _tbl[index].baudrate;
  805. }
  806. return 0;
  807. }
  808. static void _tc_flush(struct rt_serial_device *serial, int queue)
  809. {
  810. rt_base_t level;
  811. int ch = -1;
  812. struct rt_serial_rx_fifo *rx_fifo = RT_NULL;
  813. struct rt_device *device = RT_NULL;
  814. RT_ASSERT(serial != RT_NULL);
  815. device = &(serial->parent);
  816. rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
  817. switch(queue)
  818. {
  819. case TCIFLUSH:
  820. case TCIOFLUSH:
  821. RT_ASSERT(rx_fifo != RT_NULL);
  822. if((device->open_flag & RT_DEVICE_FLAG_INT_RX) || (device->open_flag & RT_DEVICE_FLAG_DMA_RX))
  823. {
  824. RT_ASSERT(RT_NULL != rx_fifo);
  825. level = rt_spin_lock_irqsave(&(serial->spinlock));
  826. rx_fifo->get_index = rx_fifo->put_index;
  827. rx_fifo->is_full = RT_FALSE;
  828. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  829. }
  830. else
  831. {
  832. while (1)
  833. {
  834. ch = serial->ops->getc(serial);
  835. if (ch == -1) break;
  836. }
  837. }
  838. break;
  839. case TCOFLUSH:
  840. break;
  841. }
  842. }
  843. static inline int _termio_to_termios(const struct termio *termio, struct termios *termios)
  844. {
  845. termios->c_iflag = termio->c_iflag;
  846. termios->c_oflag = termio->c_oflag;
  847. termios->c_cflag = termio->c_cflag;
  848. termios->c_lflag = termio->c_lflag;
  849. termios->c_line = termio->c_line;
  850. rt_memcpy(termios->c_cc, termio->c_cc, NCC);
  851. return 0;
  852. }
  853. static inline int _termios_to_termio(const struct termios *termios, struct termio *termio)
  854. {
  855. termio->c_iflag = (unsigned short)termios->c_iflag;
  856. termio->c_oflag = (unsigned short)termios->c_oflag;
  857. termio->c_cflag = (unsigned short)termios->c_cflag;
  858. termio->c_lflag = (unsigned short)termios->c_lflag;
  859. termio->c_line = termios->c_line;
  860. rt_memcpy(termio->c_cc, termios->c_cc, NCC);
  861. return 0;
  862. }
  863. #endif /* RT_USING_POSIX_TERMIOS */
  864. static rt_err_t rt_serial_control(struct rt_device *dev,
  865. int cmd,
  866. void *args)
  867. {
  868. rt_err_t ret = RT_EOK;
  869. struct rt_serial_device *serial;
  870. RT_ASSERT(dev != RT_NULL);
  871. serial = (struct rt_serial_device *)dev;
  872. switch (cmd)
  873. {
  874. case RT_DEVICE_CTRL_SUSPEND:
  875. /* suspend device */
  876. dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
  877. break;
  878. case RT_DEVICE_CTRL_RESUME:
  879. /* resume device */
  880. dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
  881. break;
  882. case RT_DEVICE_CTRL_CONFIG:
  883. if (args)
  884. {
  885. struct serial_configure *pconfig = (struct serial_configure *) args;
  886. if (pconfig->bufsz != serial->config.bufsz && serial->parent.ref_count)
  887. {
  888. /*can not change buffer size*/
  889. return -RT_EBUSY;
  890. }
  891. /* set serial configure */
  892. serial->config = *pconfig;
  893. if (serial->parent.ref_count)
  894. {
  895. /* serial device has been opened, to configure it */
  896. serial->ops->configure(serial, (struct serial_configure *) args);
  897. }
  898. }
  899. break;
  900. case RT_DEVICE_CTRL_NOTIFY_SET:
  901. if (args)
  902. {
  903. rt_memcpy(&serial->rx_notify, args, sizeof(struct rt_device_notify));
  904. }
  905. break;
  906. case RT_DEVICE_CTRL_CONSOLE_OFLAG:
  907. if (args)
  908. {
  909. *(rt_uint16_t*)args = RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM;
  910. }
  911. break;
  912. #ifdef RT_USING_POSIX_STDIO
  913. #if defined(RT_USING_POSIX_TERMIOS)
  914. case TCGETA:
  915. case TCGETS:
  916. {
  917. struct termios *tio, tmp;
  918. if (cmd == TCGETS)
  919. {
  920. tio = (struct termios*)args;
  921. }
  922. else
  923. {
  924. tio = &tmp;
  925. }
  926. if (tio == RT_NULL) return -RT_EINVAL;
  927. tio->c_iflag = 0;
  928. tio->c_oflag = 0;
  929. tio->c_lflag = 0;
  930. /* update oflag for console device */
  931. if (rt_console_get_device() == dev)
  932. tio->c_oflag = OPOST | ONLCR;
  933. /* set cflag */
  934. tio->c_cflag = 0;
  935. if (serial->config.data_bits == DATA_BITS_5)
  936. tio->c_cflag = CS5;
  937. else if (serial->config.data_bits == DATA_BITS_6)
  938. tio->c_cflag = CS6;
  939. else if (serial->config.data_bits == DATA_BITS_7)
  940. tio->c_cflag = CS7;
  941. else if (serial->config.data_bits == DATA_BITS_8)
  942. tio->c_cflag = CS8;
  943. if (serial->config.stop_bits == STOP_BITS_2)
  944. tio->c_cflag |= CSTOPB;
  945. if (serial->config.parity == PARITY_EVEN)
  946. tio->c_cflag |= PARENB;
  947. else if (serial->config.parity == PARITY_ODD)
  948. tio->c_cflag |= (PARODD | PARENB);
  949. cfsetospeed(tio, _get_speed(serial->config.baud_rate));
  950. if (cmd == TCGETA)
  951. {
  952. _termios_to_termio(tio, args);
  953. }
  954. }
  955. break;
  956. case TCSETAW:
  957. case TCSETAF:
  958. case TCSETA:
  959. case TCSETSW:
  960. case TCSETSF:
  961. case TCSETS:
  962. {
  963. int baudrate;
  964. struct serial_configure config;
  965. struct termios *tio, tmp;
  966. if ((cmd >= TCSETA) && (cmd <= TCSETA + 2))
  967. {
  968. _termio_to_termios(args, &tmp);
  969. tio = &tmp;
  970. }
  971. else
  972. {
  973. tio = (struct termios*)args;
  974. }
  975. if (tio == RT_NULL) return -RT_EINVAL;
  976. config = serial->config;
  977. baudrate = _get_baudrate(cfgetospeed(tio));
  978. config.baud_rate = baudrate;
  979. switch (tio->c_cflag & CSIZE)
  980. {
  981. case CS5:
  982. config.data_bits = DATA_BITS_5;
  983. break;
  984. case CS6:
  985. config.data_bits = DATA_BITS_6;
  986. break;
  987. case CS7:
  988. config.data_bits = DATA_BITS_7;
  989. break;
  990. default:
  991. config.data_bits = DATA_BITS_8;
  992. break;
  993. }
  994. if (tio->c_cflag & CSTOPB) config.stop_bits = STOP_BITS_2;
  995. else config.stop_bits = STOP_BITS_1;
  996. if (tio->c_cflag & PARENB)
  997. {
  998. if (tio->c_cflag & PARODD) config.parity = PARITY_ODD;
  999. else config.parity = PARITY_EVEN;
  1000. }
  1001. else config.parity = PARITY_NONE;
  1002. serial->ops->configure(serial, &config);
  1003. }
  1004. break;
  1005. #ifndef RT_USING_TTY
  1006. case TCFLSH:
  1007. {
  1008. int queue = (int)(rt_ubase_t)args;
  1009. _tc_flush(serial, queue);
  1010. }
  1011. break;
  1012. case TCXONC:
  1013. break;
  1014. #endif /*RT_USING_TTY*/
  1015. #endif /*RT_USING_POSIX_TERMIOS*/
  1016. case TIOCSWINSZ:
  1017. {
  1018. struct winsize* p_winsize;
  1019. p_winsize = (struct winsize*)args;
  1020. rt_kprintf("\x1b[8;%d;%dt", p_winsize->ws_col, p_winsize->ws_row);
  1021. }
  1022. break;
  1023. case TIOCGWINSZ:
  1024. {
  1025. struct winsize* p_winsize;
  1026. p_winsize = (struct winsize*)args;
  1027. if(rt_thread_self() != rt_thread_find("tshell"))
  1028. {
  1029. /* only can be used in tshell thread; otherwise, return default size */
  1030. p_winsize->ws_col = 80;
  1031. p_winsize->ws_row = 24;
  1032. }
  1033. else
  1034. {
  1035. #include <shell.h>
  1036. #define _TIO_BUFLEN 20
  1037. char _tio_buf[_TIO_BUFLEN];
  1038. unsigned char cnt1, cnt2, cnt3, i;
  1039. char row_s[4], col_s[4];
  1040. char *p;
  1041. rt_memset(_tio_buf, 0, _TIO_BUFLEN);
  1042. /* send the command to terminal for getting the window size of the terminal */
  1043. rt_kprintf("\033[18t");
  1044. /* waiting for the response from the terminal */
  1045. i = 0;
  1046. while(i < _TIO_BUFLEN)
  1047. {
  1048. _tio_buf[i] = finsh_getchar();
  1049. if(_tio_buf[i] != 't')
  1050. {
  1051. i ++;
  1052. }
  1053. else
  1054. {
  1055. break;
  1056. }
  1057. }
  1058. if(i == _TIO_BUFLEN)
  1059. {
  1060. /* buffer overloaded, and return default size */
  1061. p_winsize->ws_col = 80;
  1062. p_winsize->ws_row = 24;
  1063. break;
  1064. }
  1065. /* interpreting data eg: "\033[8;1;15t" which means row is 1 and col is 15 (unit: size of ONE character) */
  1066. rt_memset(row_s,0,4);
  1067. rt_memset(col_s,0,4);
  1068. cnt1 = 0;
  1069. while(cnt1 < _TIO_BUFLEN && _tio_buf[cnt1] != ';')
  1070. {
  1071. cnt1++;
  1072. }
  1073. cnt2 = ++cnt1;
  1074. while(cnt2 < _TIO_BUFLEN && _tio_buf[cnt2] != ';')
  1075. {
  1076. cnt2++;
  1077. }
  1078. p = row_s;
  1079. while(cnt1 < cnt2)
  1080. {
  1081. *p++ = _tio_buf[cnt1++];
  1082. }
  1083. p = col_s;
  1084. cnt2++;
  1085. cnt3 = rt_strlen(_tio_buf) - 1;
  1086. while(cnt2 < cnt3)
  1087. {
  1088. *p++ = _tio_buf[cnt2++];
  1089. }
  1090. /* load the window size date */
  1091. p_winsize->ws_col = atoi(col_s);
  1092. p_winsize->ws_row = atoi(row_s);
  1093. #undef _TIO_BUFLEN
  1094. }
  1095. p_winsize->ws_xpixel = 0;/* unused */
  1096. p_winsize->ws_ypixel = 0;/* unused */
  1097. }
  1098. break;
  1099. case FIONREAD:
  1100. {
  1101. rt_size_t recved = 0;
  1102. rt_base_t level;
  1103. level = rt_spin_lock_irqsave(&(serial->spinlock));
  1104. recved = _serial_fifo_calc_recved_len(serial);
  1105. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  1106. *(rt_size_t *)args = recved;
  1107. }
  1108. break;
  1109. #endif /* RT_USING_POSIX_STDIO */
  1110. default :
  1111. /* control device */
  1112. ret = serial->ops->control(serial, cmd, args);
  1113. break;
  1114. }
  1115. return ret;
  1116. }
  1117. #ifdef RT_USING_DEVICE_OPS
  1118. const static struct rt_device_ops serial_ops =
  1119. {
  1120. rt_serial_init,
  1121. rt_serial_open,
  1122. rt_serial_close,
  1123. rt_serial_read,
  1124. rt_serial_write,
  1125. rt_serial_control
  1126. };
  1127. #endif
  1128. /*
  1129. * serial register
  1130. */
  1131. rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
  1132. const char *name,
  1133. rt_uint32_t flag,
  1134. void *data)
  1135. {
  1136. rt_err_t ret;
  1137. struct rt_device *device;
  1138. RT_ASSERT(serial != RT_NULL);
  1139. rt_spin_lock_init(&(serial->spinlock));
  1140. device = &(serial->parent);
  1141. device->type = RT_Device_Class_Char;
  1142. device->rx_indicate = RT_NULL;
  1143. device->tx_complete = RT_NULL;
  1144. #ifdef RT_USING_DEVICE_OPS
  1145. device->ops = &serial_ops;
  1146. #else
  1147. device->init = rt_serial_init;
  1148. device->open = rt_serial_open;
  1149. device->close = rt_serial_close;
  1150. device->read = rt_serial_read;
  1151. device->write = rt_serial_write;
  1152. device->control = rt_serial_control;
  1153. #endif
  1154. device->user_data = data;
  1155. /* register a character device */
  1156. ret = rt_device_register(device, name, flag);
  1157. #ifdef RT_USING_POSIX_STDIO
  1158. /* set fops */
  1159. device->fops = &_serial_fops;
  1160. #endif
  1161. #if defined(RT_USING_SMART)
  1162. rt_hw_serial_register_tty(serial);
  1163. #endif
  1164. return ret;
  1165. }
  1166. #if defined(RT_USING_SMART) && defined(LWP_DEBUG)
  1167. static volatile int _early_input = 0;
  1168. int lwp_startup_debug_request(void)
  1169. {
  1170. return _early_input;
  1171. }
  1172. #endif
  1173. /* ISR for serial interrupt */
  1174. void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
  1175. {
  1176. switch (event & 0xff)
  1177. {
  1178. case RT_SERIAL_EVENT_RX_IND:
  1179. {
  1180. int ch = -1;
  1181. rt_base_t level;
  1182. struct rt_serial_rx_fifo* rx_fifo;
  1183. /* interrupt mode receive */
  1184. rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
  1185. RT_ASSERT(rx_fifo != RT_NULL);
  1186. while (1)
  1187. {
  1188. ch = serial->ops->getc(serial);
  1189. if (ch == -1) break;
  1190. /* disable interrupt */
  1191. level = rt_spin_lock_irqsave(&(serial->spinlock));
  1192. rx_fifo->buffer[rx_fifo->put_index] = ch;
  1193. rx_fifo->put_index += 1;
  1194. if (rx_fifo->put_index >= serial->config.bufsz) rx_fifo->put_index = 0;
  1195. /* if the next position is read index, discard this 'read char' */
  1196. if (rx_fifo->put_index == rx_fifo->get_index)
  1197. {
  1198. rx_fifo->get_index += 1;
  1199. rx_fifo->is_full = RT_TRUE;
  1200. if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;
  1201. _serial_check_buffer_size();
  1202. }
  1203. /* enable interrupt */
  1204. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  1205. }
  1206. /**
  1207. * Invoke callback.
  1208. * First try notify if any, and if notify is existed, rx_indicate()
  1209. * is not callback. This seperate the priority and makes the reuse
  1210. * of same serial device reasonable for RT console.
  1211. */
  1212. if (serial->rx_notify.notify)
  1213. {
  1214. serial->rx_notify.notify(serial->rx_notify.dev);
  1215. }
  1216. else if (serial->parent.rx_indicate != RT_NULL)
  1217. {
  1218. rt_size_t rx_length;
  1219. /* get rx length */
  1220. level = rt_spin_lock_irqsave(&(serial->spinlock));
  1221. rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index):
  1222. (serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index));
  1223. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  1224. if (rx_length)
  1225. {
  1226. serial->parent.rx_indicate(&serial->parent, rx_length);
  1227. }
  1228. }
  1229. #if defined(RT_USING_SMART) && defined(LWP_DEBUG)
  1230. _early_input = 1;
  1231. #endif
  1232. break;
  1233. }
  1234. case RT_SERIAL_EVENT_TX_DONE:
  1235. {
  1236. struct rt_serial_tx_fifo* tx_fifo;
  1237. tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_tx;
  1238. rt_completion_done(&(tx_fifo->completion));
  1239. break;
  1240. }
  1241. #ifdef RT_SERIAL_USING_DMA
  1242. case RT_SERIAL_EVENT_TX_DMADONE:
  1243. {
  1244. const void *data_ptr;
  1245. rt_size_t data_size;
  1246. const void *last_data_ptr;
  1247. struct rt_serial_tx_dma *tx_dma;
  1248. tx_dma = (struct rt_serial_tx_dma*) serial->serial_tx;
  1249. rt_data_queue_pop(&(tx_dma->data_queue), &last_data_ptr, &data_size, 0);
  1250. if (rt_data_queue_peek(&(tx_dma->data_queue), &data_ptr, &data_size) == RT_EOK)
  1251. {
  1252. /* transmit next data node */
  1253. tx_dma->activated = RT_TRUE;
  1254. serial->ops->dma_transmit(serial, (rt_uint8_t *)data_ptr, data_size, RT_SERIAL_DMA_TX);
  1255. }
  1256. else
  1257. {
  1258. tx_dma->activated = RT_FALSE;
  1259. }
  1260. /* invoke callback */
  1261. if (serial->parent.tx_complete != RT_NULL)
  1262. {
  1263. serial->parent.tx_complete(&serial->parent, (void*)last_data_ptr);
  1264. }
  1265. break;
  1266. }
  1267. case RT_SERIAL_EVENT_RX_DMADONE:
  1268. {
  1269. int length;
  1270. rt_base_t level;
  1271. /* get DMA rx length */
  1272. length = (event & (~0xff)) >> 8;
  1273. if (serial->config.bufsz == 0)
  1274. {
  1275. struct rt_serial_rx_dma* rx_dma;
  1276. rx_dma = (struct rt_serial_rx_dma*) serial->serial_rx;
  1277. RT_ASSERT(rx_dma != RT_NULL);
  1278. RT_ASSERT(serial->parent.rx_indicate != RT_NULL);
  1279. serial->parent.rx_indicate(&(serial->parent), length);
  1280. rx_dma->activated = RT_FALSE;
  1281. }
  1282. else
  1283. {
  1284. /* disable interrupt */
  1285. level = rt_spin_lock_irqsave(&(serial->spinlock));
  1286. /* update fifo put index */
  1287. rt_dma_recv_update_put_index(serial, length);
  1288. /* calculate received total length */
  1289. length = rt_dma_calc_recved_len(serial);
  1290. /* enable interrupt */
  1291. rt_spin_unlock_irqrestore(&(serial->spinlock), level);
  1292. /* invoke callback */
  1293. if (serial->parent.rx_indicate != RT_NULL)
  1294. {
  1295. serial->parent.rx_indicate(&(serial->parent), length);
  1296. }
  1297. }
  1298. break;
  1299. }
  1300. #endif /* RT_SERIAL_USING_DMA */
  1301. }
  1302. }