Context Navigation

source: trunk/hal/tsar_mips32/drivers/soclib_tty.c @ 578

Last change on this file since 578 was 570, checked in by alain, 6 years ago
Introduction of the soclib_mty driver for the TSAR-LETI architecture.
File size: 19.9 KB

Line
1	/*
2	* soclib_tty.c - soclib tty driver implementation.
3	*
4	* Author Alain Greiner (2016,2017,2018)
5	*
6	* Copyright (c) UPMC Sorbonne Universites
7	*
8	* This file is part of ALMOS-MKH.
9	*
10	* ALMOS-MKH. is free software; you can redistribute it and/or modify it
11	* under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; version 2.0 of the License.
13	*
14	* ALMOS-MKH is distributed in the hope that it will be useful, but
15	* WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17	* General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with ALMOS-MKH; if not, write to the Free Software Foundation,
21	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22	*/
23
24
25	#include <hal_kernel_types.h>
26	#include <dev_txt.h>
27	#include <chdev.h>
28	#include <soclib_tty.h>
29	#include <thread.h>
30	#include <printk.h>
31	#include <hal_special.h>
32
33	#if (DEBUG_SYS_READ & 1)
34	extern uint32_t enter_tty_cmd_read;
35	extern uint32_t exit_tty_cmd_read;
36
37	extern uint32_t enter_tty_isr_read;
38	extern uint32_t exit_tty_isr_read;
39	#endif
40
41	#if (DEBUG_SYS_WRITE & 1)
42	extern uint32_t enter_tty_cmd_write;
43	extern uint32_t exit_tty_cmd_write;
44
45	extern uint32_t enter_tty_isr_write;
46	extern uint32_t exit_tty_isr_write;
47	#endif
48
49	////////////////////////////////////////////////////////////////////////////////////
50	// These global variables implement the TTY_RX FIFOs (one per channel)
51	////////////////////////////////////////////////////////////////////////////////////
52	// Implementation note:
53	// We allocate - in each cluster - two arrays of FIFOs containing as many entries
54	// as the total number of TXT channels, but all entries are not used in all
55	// clusters: for a given cluster K, a given entry corresponding to a given channel
56	// and a given direction is only used if the associated chdev is in cluster K.
57	// With this policy, the driver can ignore the actual placement of chdevs.
58	////////////////////////////////////////////////////////////////////////////////////
59
60	__attribute__((section(".kdata")))
61	tty_fifo_t tty_rx_fifo[CONFIG_MAX_TXT_CHANNELS];
62
63	__attribute__((section(".kdata")))
64	tty_fifo_t tty_tx_fifo[CONFIG_MAX_TXT_CHANNELS];
65
66	///////////////////////////////////////
67	void soclib_tty_init( chdev_t * chdev )
68	{
69	xptr_t reg_xp;
70
71	// initialise function pointers in chdev
72	chdev->cmd = &soclib_tty_cmd;
73	chdev->isr = &soclib_tty_isr;
74	chdev->aux = &soclib_tty_aux;
75
76	// get TTY channel and extended pointer on TTY peripheral base address
77	xptr_t tty_xp = chdev->base;
78	uint32_t channel = chdev->channel;
79	bool_t is_rx = chdev->is_rx;
80
81	// get SOCLIB_TTY device cluster and local pointer
82	cxy_t tty_cxy = GET_CXY( tty_xp );
83	uint32_t * tty_ptr = GET_PTR( tty_xp );
84
85	// set TTY_RX_IRQ_ENABLE
86	reg_xp = XPTR( tty_cxy , tty_ptr + (channel * TTY_SPAN) + TTY_RX_IRQ_ENABLE );
87	hal_remote_s32( reg_xp , 1 );
88
89	// reset TTY_TX_IRQ_ENABLE
90	reg_xp = XPTR( tty_cxy , tty_ptr + (channel * TTY_SPAN) + TTY_TX_IRQ_ENABLE );
91	hal_remote_s32( reg_xp , 0 );
92
93	// reset relevant FIFO
94	if( is_rx )
95	{
96	tty_rx_fifo[channel].sts = 0;
97	tty_rx_fifo[channel].ptr = 0;
98	tty_rx_fifo[channel].ptw = 0;
99	}
100	else
101	{
102	tty_tx_fifo[channel].sts = 0;
103	tty_tx_fifo[channel].ptr = 0;
104	tty_tx_fifo[channel].ptw = 0;
105	}
106	} // end soclib_tty_init()
107
108	//////////////////////////////////////////////////////////////
109	void __attribute__ ((noinline)) soclib_tty_cmd( xptr_t th_xp )
110	{
111	tty_fifo_t * fifo; // TTY_RX or TTY_TX FIFO
112	char byte; // byte value
113	uint32_t done; // number of bytes moved
114
115	// get client thread cluster and local pointer
116	cxy_t th_cxy = GET_CXY( th_xp );
117	thread_t * th_ptr = GET_PTR( th_xp );
118
119	// get command arguments
120	uint32_t type = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.type ) );
121	xptr_t buf_xp = hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.buf_xp ) );
122	uint32_t count = hal_remote_l32 ( XPTR( th_cxy , &th_ptr->txt_cmd.count ) );
123	xptr_t error_xp = XPTR( th_cxy , &th_ptr->txt_cmd.error );
124
125	#if (DEBUG_SYS_READ & 1)
126	if( type == TXT_READ) enter_tty_cmd_read = (uint32_t)hal_get_cycles();
127	#endif
128
129	#if (DEBUG_SYS_WRITE & 1)
130	if( type == TXT_WRITE) enter_tty_cmd_write = (uint32_t)hal_get_cycles();
131	#endif
132
133	// get TXT device cluster and pointers
134	xptr_t dev_xp = (xptr_t)hal_remote_l64( XPTR( th_cxy , &th_ptr->txt_cmd.dev_xp ) );
135	cxy_t dev_cxy = GET_CXY( dev_xp );
136	chdev_t * dev_ptr = GET_PTR( dev_xp );
137
138	// get cluster and pointers for SOCLIB_TTY peripheral base segment
139	xptr_t tty_xp = (xptr_t)hal_remote_l64( XPTR( dev_cxy , &dev_ptr->base ) );
140	cxy_t tty_cxy = GET_CXY( tty_xp );
141	uint32_t * tty_ptr = GET_PTR( tty_xp );
142
143	// get TTY channel index and channel base address
144	uint32_t channel = hal_remote_l32( XPTR( dev_cxy , &dev_ptr->channel ) );
145	uint32_t * base = tty_ptr + TTY_SPAN * channel;
146
147	///////////////////////
148	if( type == TXT_WRITE ) // write bytes to TTY_TX FIFO
149	{
150	fifo = &tty_tx_fifo[channel];
151
152	done = 0;
153
154	while( done < count )
155	{
156	if( fifo->sts < TTY_FIFO_DEPTH ) // put one byte to FIFO if TX_FIFO not full
157	{
158	// get one byte from command buffer
159	byte = hal_remote_lb( buf_xp + done );
160
161	#if DEBUG_HAL_TXT_TX
162	uint32_t tx_cycle = (uint32_t)hal_get_cycles();
163	if( DEBUG_HAL_TXT_TX < tx_cycle )
164	printk("\n[DBG] %s : thread %x put character <%c> to TXT%d_TX fifo / cycle %d\n",
165	__FUNCTION__, CURRENT_THREAD, byte, channel, tx_cycle );
166	#endif
167	// write byte to FIFO
168	fifo->data[fifo->ptw] = byte;
169
170	// prevent race
171	hal_fence();
172
173	// update FIFO state
174	fifo->ptw = (fifo->ptw + 1) % TTY_FIFO_DEPTH;
175	hal_atomic_add( &fifo->sts , 1 );
176
177	// udate number of bytes moved
178	done++;
179
180	// enable TX_IRQ
181	hal_remote_s32( XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ) , 1 );
182	}
183	else // block & deschedule if TX_FIFO full
184	{
185	// block on ISR
186	thread_block( XPTR( local_cxy , CURRENT_THREAD ) , THREAD_BLOCKED_ISR );
187
188	// deschedule
189	sched_yield( "TTY_TX_FIFO full" );
190	}
191	}
192
193	// set error status in command and return
194	hal_remote_s32( error_xp , 0 );
195	}
196	///////////////////////////
197	else if( type == TXT_READ ) // read bytes from TTY_RX FIFO
198	{
199	fifo = &tty_rx_fifo[channel];
200
201	done = 0;
202
203	while( done < count )
204	{
205	if( fifo->sts > 0 ) // get byte from FIFO if not empty
206	{
207	// get one byte from FIFO
208	char byte = fifo->data[fifo->ptr];
209
210	#if DEBUG_HAL_TXT_RX
211	uint32_t rx_cycle = (uint32_t)hal_get_cycles();
212	if( DEBUG_HAL_TXT_RX < rx_cycle )
213	printk("\n[DBG] %s : thread %x get character <%c> from TXT%d_RX fifo / cycle %d\n",
214	__FUNCTION__, CURRENT_THREAD, byte, channel, rx_cycle );
215	#endif
216	// update FIFO state
217	fifo->ptr = (fifo->ptr + 1) % TTY_FIFO_DEPTH;
218	hal_atomic_add( &fifo->sts , -1 );
219
220	// set byte to command buffer
221	hal_remote_sb( buf_xp + done , byte );
222
223	// udate number of bytes
224	done++;
225	}
226	else // deschedule if FIFO empty
227	{
228	// block on ISR
229	thread_block( XPTR( local_cxy , CURRENT_THREAD ) , THREAD_BLOCKED_ISR );
230
231	// deschedule
232	sched_yield( "TTY_RX_FIFO empty" );
233	}
234	} // end while
235
236	// set error status in command
237	hal_remote_s32( error_xp , 0 );
238	}
239	else
240	{
241	assert( false , "illegal TXT command\n" );
242	}
243
244	#if (DEBUG_SYS_READ & 1)
245	if( type == TXT_READ ) exit_tty_cmd_read = (uint32_t)hal_get_cycles();
246	#endif
247
248	#if (DEBUG_SYS_WRITE & 1)
249	if( type == TXT_WRITE ) exit_tty_cmd_write = (uint32_t)hal_get_cycles();
250	#endif
251
252	} // end soclib_tty_cmd()
253
254	/////////////////////////////////////////////////////////////////
255	void __attribute__ ((noinline)) soclib_tty_isr( chdev_t * chdev )
256	{
257	thread_t * server; // pointer on TXT chdev server thread
258	lid_t server_lid; // local index of core running the server thread
259	uint32_t channel; // TXT chdev channel
260	bool_t is_rx; // TXT chdev direction
261	char byte; // byte value
262	xptr_t owner_xp; // extended pointer on TXT owner process
263	cxy_t owner_cxy; // TXT owner process cluster
264	process_t * owner_ptr; // local pointer on TXT owner process
265	pid_t owner_pid; // TXT owner process identifier
266	tty_fifo_t * fifo; // pointer on TTY_TX or TTY_RX FIFO
267	cxy_t tty_cxy; // soclib_tty cluster
268	uint32_t * tty_ptr; // soclib_tty segment base address
269	uint32_t * base; // soclib_tty channel base address
270	xptr_t status_xp; // extended pointer on TTY_STATUS register
271	xptr_t write_xp; // extended pointer on TTY_WRITE register
272	xptr_t read_xp; // extended pointer on TTY_READ register
273	xptr_t parent_xp; // extended pointer on parent process
274	cxy_t parent_cxy; // parent process cluster
275	process_t * parent_ptr; // local pointer on parent process
276	thread_t * parent_main_ptr; // extended pointer on parent process main thread
277	xptr_t parent_main_xp; // local pointer on parent process main thread
278
279	// get TXT chdev channel, direction, server thread, and server core
280	channel = chdev->channel;
281	is_rx = chdev->is_rx;
282	server = chdev->server;
283	server_lid = server->core->lid;
284
285	#if (DEBUG_SYS_READ & 1)
286	if( is_rx ) enter_tty_isr_read = (uint32_t)hal_get_cycles();
287	#endif
288
289	#if (DEBUG_SYS_WRITE & 1)
290	if( is_rx == 0 ) enter_tty_isr_write = (uint32_t)hal_get_cycles();
291	#endif
292
293	#if DEBUG_HAL_TXT_RX
294	uint32_t rx_cycle = (uint32_t)hal_get_cycles();
295	#endif
296
297	#if DEBUG_HAL_TXT_TX
298	uint32_t tx_cycle = (uint32_t)hal_get_cycles();
299	#endif
300
301	// get SOCLIB_TTY peripheral cluster and local pointer
302	tty_cxy = GET_CXY( chdev->base );
303	tty_ptr = GET_PTR( chdev->base );
304
305	// get channel base address
306	base = tty_ptr + TTY_SPAN * channel;
307
308	// get extended pointer on TTY registers
309	status_xp = XPTR( tty_cxy , base + TTY_STATUS );
310	write_xp = XPTR( tty_cxy , base + TTY_WRITE );
311	read_xp = XPTR( tty_cxy , base + TTY_READ );
312
313	/////////////////////////// handle RX //////////////////////
314	if( is_rx )
315	{
316	fifo = &tty_rx_fifo[channel];
317
318	// try to move bytes until TTY_READ register empty
319	while( hal_remote_l32( status_xp ) & TTY_STATUS_RX_FULL )
320	{
321	// get one byte from TTY_READ register & acknowledge RX_IRQ
322	byte = (char)hal_remote_lb( read_xp );
323
324	// filter special character ^Z => block TXT owner process
325	if( byte == 0x1A )
326	{
327
328	#if DEBUG_HAL_TXT_RX
329	if( DEBUG_HAL_TXT_RX < rx_cycle )
330	printk("\n[DBG] %s : read ^Z character from TXT%d\n", __FUNCTION__, channel );
331	#endif
332	// get pointers on TXT owner process in owner cluster
333	owner_xp = process_txt_get_owner( channel );
334
335	// check process exist
336	assert( (owner_xp != XPTR_NULL) ,
337	"TXT owner process not found\n" );
338
339	// get relevant infos on TXT owner process
340	owner_cxy = GET_CXY( owner_xp );
341	owner_ptr = GET_PTR( owner_xp );
342	owner_pid = hal_remote_l32( XPTR( owner_cxy , &owner_ptr->pid ) );
343
344	// block TXT owner process only if it is not the INIT process
345	if( owner_pid != 1 )
346	{
347	// get parent process descriptor pointers
348	parent_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
349	parent_cxy = GET_CXY( parent_xp );
350	parent_ptr = GET_PTR( parent_xp );
351
352	// get pointers on the parent process main thread
353	parent_main_ptr = hal_remote_lpt(XPTR(parent_cxy,&parent_ptr->th_tbl[0]));
354	parent_main_xp = XPTR( parent_cxy , parent_main_ptr );
355
356	// transfer TXT ownership
357	process_txt_transfer_ownership( owner_xp );
358
359	// block all threads in all clusters, but the main thread
360	process_sigaction( owner_pid , BLOCK_ALL_THREADS );
361
362	// block the main thread
363	xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
364	thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
365
366	// atomically update owner process termination state
367	hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
368	PROCESS_TERM_STOP );
369
370	// unblock the parent process main thread
371	thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
372
373	return;
374	}
375	}
376
377	// filter special character ^C => kill TXT owner process
378	if( byte == 0x03 )
379	{
380
381	#if DEBUG_HAL_TXT_RX
382	if( DEBUG_HAL_TXT_RX < rx_cycle )
383	printk("\n[DBG] %s : read ^C character from TXT%d\n", __FUNCTION__, channel );
384	#endif
385	// get pointer on TXT owner process in owner cluster
386	owner_xp = process_txt_get_owner( channel );
387
388	// check process exist
389	assert( (owner_xp != XPTR_NULL) ,
390	"TXT owner process not found\n" );
391
392	// get relevant infos on TXT owner process
393	owner_cxy = GET_CXY( owner_xp );
394	owner_ptr = GET_PTR( owner_xp );
395	owner_pid = hal_remote_l32( XPTR( owner_cxy , &owner_ptr->pid ) );
396
397	// kill TXT owner process only if it is not the INIT process
398	if( owner_pid != 1 )
399	{
400	// get parent process descriptor pointers
401	parent_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->parent_xp ) );
402	parent_cxy = GET_CXY( parent_xp );
403	parent_ptr = GET_PTR( parent_xp );
404
405	// get pointers on the parent process main thread
406	parent_main_ptr = hal_remote_lpt(XPTR(parent_cxy,&parent_ptr->th_tbl[0]));
407	parent_main_xp = XPTR( parent_cxy , parent_main_ptr );
408
409	// remove process from TXT list
410	process_txt_detach( owner_xp );
411
412	// mark for delete all thread in all clusters, but the main
413	process_sigaction( owner_pid , DELETE_ALL_THREADS );
414
415	// block main thread
416	xptr_t main_xp = XPTR( owner_cxy , &owner_ptr->th_tbl[0] );
417	thread_block( main_xp , THREAD_BLOCKED_GLOBAL );
418
419	// atomically update owner process termination state
420	hal_remote_atomic_or( XPTR( owner_cxy , &owner_ptr->term_state ) ,
421	PROCESS_TERM_KILL );
422
423	// unblock the parent process main thread
424	thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
425
426	return;
427	}
428	}
429
430	// write byte in TTY_RX FIFO if not full / discard byte if full
431	if ( fifo->sts < TTY_FIFO_DEPTH )
432	{
433
434	#if DEBUG_HAL_TXT_RX
435	if( DEBUG_HAL_TXT_RX < rx_cycle )
436	printk("\n[DBG] %s : put character <%c> to TXT%d_RX fifo\n",
437	__FUNCTION__, byte, channel );
438	#endif
439	// store byte into FIFO
440	fifo->data[fifo->ptw] = (char)byte;
441
442	// avoid race
443	hal_fence();
444
445	// update RX_FIFO state
446	fifo->ptw = (fifo->ptw + 1) % TTY_FIFO_DEPTH;
447	hal_atomic_add( &fifo->sts , 1 );
448
449	// unblock TXT_RX server thread
450	thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
451
452	// send IPI to core running server thread if required
453	if( server_lid != CURRENT_THREAD->core->lid )
454	{
455	dev_pic_send_ipi( local_cxy , server_lid );
456	}
457	}
458	else
459	{
460	printk("\n[WARNING] %s : TTY_RX_FIFO[%d] full => discard character <%x>\n",
461	__FUNCTION__, channel, (uint32_t)byte );
462	}
463	} // end while TTY_READ register full
464
465	} // end RX
466
467	/////////////////////// handle TX /////////////////////////////
468	else
469	{
470	fifo = &tty_tx_fifo[channel];
471
472	// try to move bytes until TX_FIFO empty
473	while( fifo->sts > 0 )
474	{
475	// write one byte to TTY_WRITE register if empty / exit loop if full
476	if( (hal_remote_l32( status_xp ) & TTY_STATUS_TX_FULL) == 0 )
477	{
478	// get one byte from TX_FIFO
479	byte = fifo->data[fifo->ptr];
480
481	#if DEBUG_HAL_TXT_TX
482	if( DEBUG_HAL_TXT_TX < tx_cycle )
483	printk("\n[DBG] %s : get character <%c> from TXT%d_TX fifo\n",
484	__FUNCTION__, byte, channel );
485	#endif
486	// update TX_FIFO state
487	fifo->ptr = (fifo->ptr + 1) % TTY_FIFO_DEPTH;
488	hal_atomic_add( &fifo->sts , -1 );
489
490	// write byte to TTY_WRITE register & acknowledge TX_IRQ
491	hal_remote_sb( write_xp , byte );
492	}
493	}
494
495	// disable TX_IRQ
496	hal_remote_s32( XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE ) , 0 );
497
498	// unblock TXT_TX server thread
499	thread_unblock( XPTR( local_cxy , server ) , THREAD_BLOCKED_ISR );
500
501	// send IPI to core running server thread if required
502	if( server_lid != CURRENT_THREAD->core->lid )
503	{
504	dev_pic_send_ipi( local_cxy , server_lid );
505	}
506
507	} // end TX
508
509	hal_fence();
510
511	#if (DEBUG_SYS_READ & 1)
512	if( is_rx ) exit_tty_isr_read = (uint32_t)hal_get_cycles();
513	#endif
514
515	#if (DEBUG_SYS_WRITE & 1)
516	if( is_rx == 0 ) exit_tty_isr_write = (uint32_t)hal_get_cycles();
517	#endif
518
519	} // end soclib_tty_isr()
520
521	/////////////////////////////////////////////////////////////
522	void __attribute__ ((noinline)) soclib_tty_aux( void * args )
523	{
524	uint32_t status;
525	bool_t empty;
526	uint32_t i;
527
528	xptr_t dev_xp = ((txt_sync_args_t *)args)->dev_xp;
529	const char * buffer = ((txt_sync_args_t *)args)->buffer;
530	uint32_t count = ((txt_sync_args_t *)args)->count;
531
532	// get chdev cluster and local pointer
533	cxy_t dev_cxy = GET_CXY( dev_xp );
534	chdev_t * dev_ptr = GET_PTR( dev_xp );
535
536	// get extended pointer on TTY channel base address
537	xptr_t tty_xp = (xptr_t)hal_remote_l64( XPTR( dev_cxy , &dev_ptr->base ) );
538
539	// get TTY channel segment cluster and local pointer
540	cxy_t tty_cxy = GET_CXY( tty_xp );
541	uint32_t * tty_ptr = GET_PTR( tty_xp );
542
543	// get extended pointers on TTY_WRITE & TTY_STATUS registers
544	xptr_t write_xp = XPTR( tty_cxy , tty_ptr + TTY_WRITE );
545	xptr_t status_xp = XPTR( tty_cxy , tty_ptr + TTY_STATUS );
546
547	// loop on characters
548	for( i = 0 ; i < count ; i++ )
549	{
550	// busy waiting policy on TTY_STATUS register
551	do
552	{
553	// get TTY_STATUS
554	status = hal_remote_l32( status_xp );
555	empty = ( (status & TTY_STATUS_TX_FULL) == 0 );
556
557	// transfer one byte if TX buffer empty
558	if ( empty ) hal_remote_sb( write_xp , buffer[i] );
559	}
560	while ( empty == false );
561	}
562	} // end soclib_tty_aux()
563
564
565

Note: See TracBrowser for help on using the repository browser.

Download in other formats: