1 /*
2  * Copyright (c) 2006-2024 RT-Thread Development Team
3  *
4  * SPDX-License-Identifier: Apache-2.0
5  *
6  * Change Logs:
7  * Date           Author       Notes
8  * 2024-11-20     zhujiale     the first version
9  */
10 
11 #include<rtdevice.h>
12 #define DBG_TAG    "UART"
13 #define DBG_LVL    DBG_INFO
14 #include <rtdbg.h>
15 
rt_bypass_alloc_func(const char * name,rt_uint8_t level,bypass_function_t func,void * data)16 static struct rt_serial_bypass_func* rt_bypass_alloc_func(const char* name, rt_uint8_t level, bypass_function_t func, void* data)
17 {
18     struct rt_serial_bypass_func* bypass;
19 
20     if (!func)
21         return RT_NULL;
22 
23     bypass = rt_malloc(sizeof(struct rt_serial_bypass_func));
24     rt_memset(bypass, 0, sizeof(struct rt_serial_bypass_func));
25 
26     if (rt_strlen(name) > RT_NAME_MAX - 1)
27         rt_memcpy(bypass->name, name, RT_NAME_MAX);
28     else
29         rt_memcpy(bypass->name, name, rt_strlen(name) + 1);
30 
31     bypass->level = level;
32 
33     rt_list_init(&bypass->node);
34     bypass->bypass = func;
35     bypass->data = data;
36 
37     return bypass;
38 }
39 
rt_serial_bypass_init(struct rt_serial_device * serial)40 rt_err_t rt_serial_bypass_init(struct rt_serial_device* serial)
41 {
42     serial->bypass = rt_malloc(sizeof(struct rt_serial_bypass));
43     rt_memset(serial->bypass, 0, sizeof(struct rt_serial_bypass));
44 #ifdef RT_USING_SERIAL_V2
45     serial->bypass->pipe = rt_ringbuffer_create(serial->config.rx_bufsz);
46 #else
47     serial->bypass->pipe = rt_ringbuffer_create(serial->config.bufsz);
48 #endif
49     serial->bypass->mutex = rt_mutex_create("serial_bypass", RT_IPC_FLAG_FIFO);
50 
51     return RT_EOK;
52 }
53 
rt_bypass_register(struct rt_serial_bypass_head * bypass,const char * name,rt_uint8_t level,bypass_function_t func,void * data)54 static rt_err_t rt_bypass_register(struct rt_serial_bypass_head* bypass, const char* name, rt_uint8_t level, bypass_function_t func, void* data)
55 {
56     struct rt_serial_bypass_func* pass = RT_NULL;
57     struct rt_list_node* node;
58     int flags;
59 
60     RT_DEBUG_NOT_IN_INTERRUPT;
61 
62     pass = rt_bypass_alloc_func(name, level, func, data);
63 
64     RT_ASSERT(bypass != RT_NULL);
65 
66     node = bypass->head.next;
67 
68     if (node == &bypass->head)
69     {
70         rt_list_insert_before(&pass->node, node);
71         return RT_EOK;
72     }
73     flags = rt_spin_lock_irqsave(&(bypass->spinlock));
74     do {
75         struct rt_serial_bypass_func* temp_curr;
76         temp_curr = rt_container_of(node, struct rt_serial_bypass_func, node);
77 
78         if (level < temp_curr->level)
79         {
80             rt_list_insert_before(node, &pass->node);
81 
82             rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
83             return RT_EOK;
84         }
85         else if (level == temp_curr->level)
86         {
87             rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
88             LOG_E("Conflict: bypass [%s] level conflicts with [%s] at level [%d]\n", name, temp_curr->name, level);
89             rt_free(pass);
90             return -RT_ERROR;
91         }
92 
93         node = node->next;
94 
95     } while (node != &bypass->head);
96 
97     rt_list_insert_before(&bypass->head, &pass->node);
98 
99     rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
100     return RT_EOK;
101 
102 }
103 
rt_bypass_upper_register(struct rt_serial_device * serial,const char * name,rt_uint8_t level,bypass_function_t func,void * data)104 rt_err_t rt_bypass_upper_register(struct rt_serial_device* serial, const char* name, rt_uint8_t level, bypass_function_t func, void* data)
105 {
106     if (!serial->bypass)
107         rt_serial_bypass_init(serial);
108 
109     if (!serial->bypass->upper_h)
110     {
111         serial->bypass->upper_h = rt_malloc(sizeof(struct rt_serial_bypass_head));
112         rt_spin_lock_init(&serial->bypass->upper_h->spinlock);
113         rt_list_init(&serial->bypass->upper_h->head);
114 
115     }
116 
117     return rt_bypass_register(serial->bypass->upper_h, name, level, func, data);
118 }
119 
120 
121 
rt_bypass_putchar(struct rt_serial_device * serial,rt_uint8_t ch)122 void rt_bypass_putchar(struct rt_serial_device* serial, rt_uint8_t ch)
123 {
124     rt_mutex_take(serial->bypass->mutex, RT_WAITING_FOREVER);
125     rt_ringbuffer_putchar(serial->bypass->pipe, ch);
126     rt_mutex_release(serial->bypass->mutex);
127 }
128 
rt_bypass_getchar(struct rt_serial_device * serial,rt_uint8_t * ch)129 rt_size_t rt_bypass_getchar(struct rt_serial_device* serial, rt_uint8_t* ch)
130 {
131     int flags;
132     rt_mutex_take(serial->bypass->mutex, RT_WAITING_FOREVER);
133     flags = rt_ringbuffer_getchar(serial->bypass->pipe, ch);
134     rt_mutex_release(serial->bypass->mutex);
135     return flags;
136 }
137 
_bypass_getchar_form_serial_fifo(struct rt_serial_device * serial,char * ch)138 static inline rt_err_t _bypass_getchar_form_serial_fifo(struct rt_serial_device* serial, char* ch)
139 {
140     rt_base_t level;
141     struct rt_serial_rx_fifo* rx_fifo;
142     rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
143     /* disable interrupt */
144     level = rt_spin_lock_irqsave(&(serial->spinlock));
145 
146     /* there's no data: */
147 #ifdef RT_USING_SERIAL_V2
148     rt_size_t  ringbuf_date_stat;
149     ringbuf_date_stat = rt_ringbuffer_data_len(&rx_fifo->rb);
150     if(!ringbuf_date_stat)
151     {
152         /* no data, enable interrupt and break out */
153         rt_spin_unlock_irqrestore(&(serial->spinlock), level);
154         return -RT_EEMPTY;
155     }
156     if(!rt_ringbuffer_getchar(&rx_fifo->rb, (rt_uint8_t *)ch))
157     {
158         /* Failed to read data */
159         rt_spin_unlock_irqrestore(&(serial->spinlock), level);
160         return -RT_EOK;
161     }
162 #else
163     if ((rx_fifo->get_index == rx_fifo->put_index) && (rx_fifo->is_full == RT_FALSE))
164     {
165         /* no data, enable interrupt and break out */
166         rt_spin_unlock_irqrestore(&(serial->spinlock), level);
167         return -RT_EEMPTY;
168     }
169 
170     /* otherwise there's the data: */
171     *ch = rx_fifo->buffer[rx_fifo->get_index];
172     rx_fifo->get_index += 1;
173     if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;
174 
175     if (rx_fifo->is_full == RT_TRUE)
176     {
177         rx_fifo->is_full = RT_FALSE;
178     }
179 #endif
180     /* enable interrupt */
181     rt_spin_unlock_irqrestore(&(serial->spinlock), level);
182 
183     return RT_EOK;
184 }
185 
_lower_work(struct rt_serial_device * serial)186 static void _lower_work(struct rt_serial_device* serial)
187 {
188     struct rt_list_node* node;
189     struct rt_serial_bypass_func* temp_curr = RT_NULL;
190     if (serial->bypass && serial->bypass->lower_h)
191     {
192         while (1)
193         {
194             char ch;
195             if (_bypass_getchar_form_serial_fifo(serial, &ch))
196                 return;
197 
198             node = serial->bypass->lower_h->head.next;
199 
200             while (node != &serial->bypass->lower_h->head)
201             {
202                 temp_curr = rt_container_of(node, struct rt_serial_bypass_func, node);
203 
204                 if (!temp_curr->bypass(serial, ch, temp_curr->data))
205                 {
206                     break;
207                 }
208 
209                 node = node->next;
210             }
211             if (node == &serial->bypass->lower_h->head)
212             {
213                 rt_bypass_putchar(serial, ch);
214             }
215         }
216     }
217 }
218 
219 
rt_lower_work(struct rt_work * work,void * work_data)220 static void rt_lower_work(struct rt_work* work, void* work_data)
221 {
222     struct rt_serial_device* serial = (struct rt_serial_device*)work_data;
223 
224     RT_ASSERT(serial != RT_NULL);
225 
226     _lower_work(serial);
227 }
228 
rt_bypass_lower_register(struct rt_serial_device * serial,const char * name,rt_uint8_t level,bypass_function_t func,void * data)229 rt_err_t rt_bypass_lower_register(struct rt_serial_device* serial, const char* name, rt_uint8_t level, bypass_function_t func, void* data)
230 {
231     if (!serial->bypass)
232         rt_serial_bypass_init(serial);
233 
234     if (!serial->bypass->lower_h)
235     {
236         serial->bypass->lower_workq = rt_workqueue_create("serial bypass", RT_SYSTEM_WORKQUEUE_STACKSIZE,
237             RT_SYSTEM_WORKQUEUE_PRIORITY);
238         rt_work_init(&serial->bypass->work, rt_lower_work, (void*)serial);
239 
240         serial->bypass->lower_h = rt_malloc(sizeof(struct rt_serial_bypass_head));
241         rt_spin_lock_init(&serial->bypass->lower_h->spinlock);
242         rt_list_init(&serial->bypass->lower_h->head);
243 
244     }
245 
246     return rt_bypass_register(serial->bypass->lower_h, name, level, func, data);
247 }
248 
rt_bypass_work_straight(struct rt_serial_device * serial)249 void rt_bypass_work_straight(struct rt_serial_device* serial)
250 {
251     if (serial->bypass && serial->bypass->lower_h)
252     {
253         _lower_work(serial);
254         return;
255     }
256 
257     while (1)
258     {
259         char ch;
260         if (_bypass_getchar_form_serial_fifo(serial, &ch))
261             return;
262 
263         rt_bypass_putchar(serial, ch);
264     }
265 
266 }
267 
rt_bypass_unregister(struct rt_serial_bypass_head * bypass,rt_uint8_t level)268 rt_err_t rt_bypass_unregister(struct rt_serial_bypass_head* bypass, rt_uint8_t level)
269 {
270     struct rt_list_node* node;
271     struct rt_serial_bypass_func* temp_curr = RT_NULL;
272     int flags;
273 
274     /*Can not unregister protect level in bypass it general be msh or tty*/
275     if (level > RT_BYPASS_PROTECT_LEVEL_1)
276         return -RT_ERROR;
277 
278     if (!bypass)
279         return -RT_ERROR;
280 
281     node = bypass->head.next;
282     flags = rt_spin_lock_irqsave(&(bypass->spinlock));
283 
284     do {
285         temp_curr = rt_container_of(node, struct rt_serial_bypass_func, node);
286 
287         if (level == temp_curr->level)
288         {
289             rt_list_remove(node);
290             rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
291             rt_free(temp_curr);
292             return RT_EOK;
293         }
294 
295         node = node->next;
296     } while (node != &bypass->head);
297 
298     LOG_E("Can't find bypass with level [%d]", level);
299     rt_spin_unlock_irqrestore(&(bypass->spinlock), flags);
300     return -RT_ERROR;
301 }
302 
rt_bypass_upper_unregister(struct rt_serial_device * serial,rt_uint8_t level)303 rt_err_t rt_bypass_upper_unregister(struct rt_serial_device* serial, rt_uint8_t level)
304 {
305     if (!serial->bypass || !serial->bypass->upper_h)
306         return -RT_ERROR;
307     return rt_bypass_unregister(serial->bypass->upper_h, level);
308 }
309 
rt_bypass_lower_unregister(struct rt_serial_device * serial,rt_uint8_t level)310 rt_err_t rt_bypass_lower_unregister(struct rt_serial_device* serial, rt_uint8_t level)
311 {
312     if (!serial->bypass || !serial->bypass->lower_h)
313         return -RT_ERROR;
314     return rt_bypass_unregister(serial->bypass->lower_h, level);
315 }
316 
serial_bypass_list(int argc,char ** argv)317 int serial_bypass_list(int argc, char** argv)
318 {
319     struct rt_serial_device* serial = RT_NULL;
320     struct rt_serial_bypass_func* current;
321     struct rt_list_node* node;
322     int flags;
323 
324     serial = (struct rt_serial_device*)rt_console_get_device();
325     if (!serial || !serial->bypass)
326     {
327         rt_kprintf("Serial bypass not initialized.\n");
328         return -1;
329     }
330 
331     /* 遍历 Upper Bypass 链表 */
332     if (serial->bypass->upper_h)
333     {
334         rt_kprintf("Upper bypass chain:\n");
335         node = serial->bypass->upper_h->head.next;
336 
337         flags = rt_spin_lock_irqsave(&(serial->bypass->upper_h->spinlock)); /* 加锁*/
338         while (node != &serial->bypass->upper_h->head)
339         {
340             current = rt_container_of(node, struct rt_serial_bypass_func, node);
341             rt_kprintf(" - Name: [%s], Level: [%d]\n", current->name, current->level);
342             node = node->next;
343         }
344         rt_spin_unlock_irqrestore(&(serial->bypass->upper_h->spinlock), flags); /* 解锁*/
345     }
346     else
347     {
348         rt_kprintf("Upper bypass chain is empty.\n");
349     }
350 
351     /* 遍历 Lower Bypass 链表 */
352     if (serial->bypass->lower_h)
353     {
354         rt_kprintf("Lower bypass chain:\n");
355         node = serial->bypass->lower_h->head.next;
356 
357         flags = rt_spin_lock_irqsave(&(serial->bypass->lower_h->spinlock)); /* 加锁*/
358         while (node != &serial->bypass->lower_h->head)
359         {
360             current = rt_container_of(node, struct rt_serial_bypass_func, node);
361             rt_kprintf(" - Name: [%s], Level: [%d]\n", current->name, current->level);
362             node = node->next;
363         }
364         rt_spin_unlock_irqrestore(&(serial->bypass->lower_h->spinlock), flags); /* 解锁*/
365     }
366     else
367     {
368         rt_kprintf("Lower bypass chain is empty.\n");
369     }
370 
371     return 0;
372 }
373 
374 
375 MSH_CMD_EXPORT(serial_bypass_list, serial bypass list)
376