source: trunk/hal/tsar_mips32/core/hal_remote.c @ 279

Last change on this file since 279 was 279, checked in by alain, 4 years ago

1) Introduce independant command fields for the various devices in the thread descriptor.
2) Introduce a new dev_pic_enable_ipi() function in the generic PIC device
3) Fix two bugs identified by Maxime in the scheduler initialisation, and in the sched_select().
4) fix several bugs in the TSAR hal_kentry.S.
5) Introduce a third kgiet segment (besides kdata and kcode) in the TSAR bootloader.

File size: 15.7 KB
Line 
1/*
2 * hal_remote.c - implementation of Generic Remote Access API for TSAR-MIPS32
3 *
4 * Authors : Mohammed Karaoui (2015)
5 *           Alain Greiner    (2016)
6 *
7 * Copyright (c) UPMC Sorbonne Universites
8 *
9 * This file is part of ALMOS-MKH..
10 *
11 * ALMOS-MKH. is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2.0 of the License.
14 *
15 * ALMOS-MKH. is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with ALMOS-MKH.; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25#include <hal_types.h>
26#include <hal_irqmask.h>
27
28////////////////////////////////
29void hal_remote_sb( xptr_t   xp,
30                    uint8_t  data )
31{
32    uint32_t save_sr;
33    uint32_t ptr = (uint32_t)GET_PTR( xp );
34    uint32_t cxy = (uint32_t)GET_CXY( xp );
35
36/* TODO improve all hal remote functions to include SR handling in assembly code */
37/* as it is done below for hal_remote_sb                                         */
38
39    asm volatile( 
40        ".set noreorder              \n"
41        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR      */
42        "srl    $13,    $14,    1    \n" 
43        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked   */
44        "mtc0   $13,    $12          \n"  /* IRQ disabled       */
45       
46
47        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */   
48        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
49        "sb     %0,     0(%1)        \n"  /* *paddr <= value    */
50        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
51
52        "mtc0   $14,    $12          \n"  /* SR restored        */
53
54        "sync                        \n"
55        ".set reorder                \n"
56        : : "r" (data), "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
57}
58
59/////////////////////////////////
60void hal_remote_sw( xptr_t    xp,
61                    uint32_t  data )
62{
63    uint32_t save_sr;
64    uint32_t ptr = (uint32_t)GET_PTR( xp );
65    uint32_t cxy = (uint32_t)GET_CXY( xp );
66
67    hal_disable_irq( &save_sr );
68
69    asm volatile( "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT */   
70        ".set noreorder              \n"
71        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy */   
72        "sw     %0,     0(%1)        \n"  /* *paddr <= value  */
73        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15 */   
74        "sync                        \n"
75        ".set reorder                \n"
76        : : "r" (data), "r" (ptr), "r" (cxy) : "$15" );
77
78    hal_restore_irq( save_sr );
79
80}
81
82//////////////////////////////////
83void hal_remote_swd( xptr_t    xp,
84                     uint64_t  data )
85{
86    uint32_t save_sr;
87    uint32_t ptr = (uint32_t)GET_PTR( xp );
88    uint32_t cxy = (uint32_t)GET_CXY( xp );
89
90    uint32_t data_lsb = (uint32_t)data;
91    uint32_t data_msb = (uint32_t)(data>>32);
92
93    hal_disable_irq( &save_sr );
94
95    asm volatile( 
96        ".set noreorder              \n"
97        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT  */   
98        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy  */   
99        "sw     %0,     0(%2)        \n"  /* *paddr <= lsb     */
100        "sw     %1,     4(%2)        \n"  /* *(paddr+4) <= msb */
101        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15  */   
102        "sync                        \n"
103        ".set reorder                \n"
104        : : "r" (data_lsb), "r" (data_msb), "r" (ptr), "r" (cxy) : "$15" );
105
106    hal_restore_irq( save_sr );
107
108}
109
110////////////////////////////////////
111void hal_remote_spt( xptr_t      xp,
112                     void *      pt )
113{
114    hal_remote_sw ( xp , (uint32_t)pt );
115}
116
117////////////////////////////////
118uint8_t hal_remote_lb( xptr_t  xp )
119{
120    uint32_t save_sr;
121        char     data;
122    uint32_t ptr = (uint32_t)GET_PTR( xp );
123    uint32_t cxy = (uint32_t)GET_CXY( xp );
124
125    hal_disable_irq( &save_sr );
126
127    asm volatile( 
128        ".set noreorder              \n"
129        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */ 
130        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
131        "lb     %0,     0(%1)        \n"  /* data <= *paddr     */
132        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
133        ".set reorder                \n"
134        : "=r" (data) : "r" (ptr), "r" (cxy) : "$15" );
135
136    hal_restore_irq( save_sr );
137
138        return ( data );
139}
140
141////////////////////////////////////
142uint32_t hal_remote_lw( xptr_t  xp )
143{
144    uint32_t save_sr;
145        uint32_t data;
146    uint32_t ptr = (uint32_t)GET_PTR( xp );
147    uint32_t cxy = (uint32_t)GET_CXY( xp );
148
149    hal_disable_irq( &save_sr );
150
151    asm volatile( 
152        ".set noreorder              \n"
153        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */ 
154        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
155        "lw     %0,     0(%1)        \n"  /* data <= *paddr     */
156        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
157        ".set reorder                \n"
158        : "=r" (data) : "r" (ptr), "r" (cxy) : "$15" );
159
160    hal_restore_irq( save_sr );
161
162    return ( data );
163}
164
165/////////////////////////////////////
166uint64_t hal_remote_lwd( xptr_t  xp )
167{
168    uint32_t save_sr;
169    uint32_t data_lsb;
170    uint32_t data_msb;
171    uint32_t ptr = (uint32_t)GET_PTR( xp );
172    uint32_t cxy = (uint32_t)GET_CXY( xp );
173
174    hal_disable_irq( &save_sr );
175
176    asm volatile( 
177        ".set noreorder              \n"
178        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
179        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
180        "lw     %0,     0(%2)        \n"  /* data_lsb <= *paddr   */
181        "lw     %1,     4(%2)        \n"  /* data_msb <= *paddr+4 */
182        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
183        ".set reorder                \n"
184        : "=r" (data_lsb), "=r"(data_msb) : "r" (ptr), "r" (cxy) : "$15" );
185
186    hal_restore_irq( save_sr );
187
188    return ( (((uint64_t)data_msb)<<32) + (((uint64_t)data_lsb)) );
189
190}
191
192////////////////////////////////////
193void * hal_remote_lpt( xptr_t    xp )
194{
195    return (void *)hal_remote_lw ( xp );
196}
197
198///////////////////////////////////////////
199bool_t hal_remote_atomic_cas( xptr_t    xp,
200                              uint32_t  old,
201                              uint32_t  new )
202{
203    uint32_t save_sr;
204        bool_t   isAtomic;
205    uint32_t ptr = (uint32_t)GET_PTR( xp );
206    uint32_t cxy = (uint32_t)GET_CXY( xp );
207
208    hal_disable_irq( &save_sr );
209
210    asm volatile( 
211        ".set noreorder              \n"
212        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */ 
213        "mtc2   %4,     $24          \n"  /* PADDR_EXT <= cxy   */   
214        "or     $8,     $0,    %3    \n"  /* $8 <= new          */
215        "ll     $3,    0(%1)         \n"  /* $3 <= *paddr       */
216        "bne    $3,     %2,    1f    \n"  /* if ($3 != old)     */
217        "li     $7,     0            \n"  /* $7 <= 0            */
218        "sc     $8,     (%1)         \n"  /* *paddr <= new      */
219        "or     $7,     $8,    $0    \n"  /* $7 <= atomic       */
220        "sync                        \n"
221        "1:                          \n"
222        "or     %0,     $7,    $0    \n"  /* isAtomic <= $7     */
223        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
224        ".set reorder                \n"
225        : "=&r" (isAtomic) : "r" (ptr), "r" (old) , "r" (new), "r" (cxy) 
226                : "$3", "$7", "$8", "$15" );
227
228    hal_restore_irq( save_sr );
229
230        return isAtomic;
231
232}  // end hal_remote_atomic_cas()
233
234////////////////////////////////////////////
235uint32_t hal_remote_atomic_add( xptr_t   xp, 
236                                uint32_t incr )
237{       
238    uint32_t save_sr;
239        uint32_t current;
240    uint32_t ptr = (uint32_t)GET_PTR( xp );
241    uint32_t cxy = (uint32_t)GET_CXY( xp );
242
243    hal_disable_irq( &save_sr );
244
245    asm volatile( 
246        ".set noreorder              \n"
247        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
248        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
249        "1:                          \n"
250        "ll     %0,     (%1)         \n"  /* current <= *paddr    */
251        "addu   $3,     %0,     %2   \n"  /* $3 <= current + incr */
252        "sc     $3,     (%1)         \n"  /* *paddr <= $3         */
253        "beq    $3,     $0,     1b   \n"  /* retry if failure     */
254        "nop                         \n"
255        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
256        ".set reorder                \n"
257                : "=&r" (current) : "r" (ptr), "r" (incr), "r" (cxy) : "$3", "$15" );
258
259    hal_restore_irq( save_sr );
260
261        return current;
262
263}  // end hal_remote_atomic_add()
264
265////////////////////////////////////////////
266uint32_t hal_remote_atomic_and( xptr_t   xp, 
267                                uint32_t mask )
268{       
269    uint32_t save_sr;
270        uint32_t current;
271    uint32_t ptr = (uint32_t)GET_PTR( xp );
272    uint32_t cxy = (uint32_t)GET_CXY( xp );
273
274    hal_disable_irq( &save_sr );
275
276    asm volatile( 
277        ".set noreorder              \n"
278        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
279        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
280        "1:                          \n"
281        "ll     %0,     (%1)         \n"  /* current <= *paddr    */
282        "and    $3,     %0,     %2   \n"  /* $3 <= current & mask */
283        "sc     $3,     (%1)         \n"  /* *paddr <= $3         */
284        "beq    $3,     $0,     1b   \n"  /* retry if failure     */
285        "nop                         \n"
286        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
287        ".set reorder                \n"
288            : "=&r" (current) : "r" (ptr), "r" (mask), "r" (cxy) : "$3", "$15" );
289
290    hal_restore_irq( save_sr );
291
292        return current;
293
294}  // end hal_remote_atomic_and()
295
296////////////////////////////////////////////
297uint32_t hal_remote_atomic_or( xptr_t   xp, 
298                               uint32_t mask )
299{       
300    uint32_t save_sr;
301        uint32_t current;
302    uint32_t ptr = (uint32_t)GET_PTR( xp );
303    uint32_t cxy = (uint32_t)GET_CXY( xp );
304
305    hal_disable_irq( &save_sr );
306
307    asm volatile( 
308        ".set noreorder              \n"
309        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
310        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
311        "1:                          \n"
312        "ll     %0,     (%1)         \n"  /* current <= *paddr    */
313        "or     $3,     %0,     %2   \n"  /* $3 <= current | mask */
314        "sc     $3,     (%1)         \n"  /* *paddr <= $3         */
315        "beq    $3,     $0,     1b   \n"  /* retry if failure     */
316        "nop                         \n"
317        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
318        ".set reorder                \n"
319            : "=&r" (current) : "r" (ptr), "r" (mask), "r" (cxy) : "$3", "$15" );
320
321    hal_restore_irq( save_sr );
322
323        return current;
324
325}  // end hal_remote_atomic_or()
326
327/////////////////////////////////////////////////
328error_t hal_remote_atomic_try_add( xptr_t     xp,
329                                   uint32_t   incr,
330                                   uint32_t * old )
331{
332    uint32_t save_sr;
333        uint32_t current;
334        error_t  error;
335    uint32_t ptr = (uint32_t)GET_PTR( xp );
336    uint32_t cxy = (uint32_t)GET_CXY( xp );
337
338    hal_disable_irq( &save_sr );
339
340    asm volatile( 
341        ".set noreorder              \n"
342        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
343        "mtc2   %4,     $24          \n"  /* PADDR_EXT <= cxy     */   
344        "ll     %0,     (%2)         \n"  /* current <= *paddr    */
345        "addu   $3,     %0,     %3   \n"  /* $3 <= current + incr */
346        "sc     $3,     (%2)         \n"  /* *paddr <= $3         */
347        "beq    $3,     $0,     1f   \n"  /* exit if failure      */
348        "ori    %1,     $0,      1   \n"  /* fail: ret <= 1       */
349        "and    %1,     $0,     $0   \n"  /* success: ret <= 0    */
350        "1:                          \n"
351        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
352        ".set reorder                \n"
353                : "=&r" (current), "=&r" (error) : "r" (ptr), "r" (incr), "r" (cxy) : "$3", "$15" );
354               
355    hal_restore_irq( save_sr );
356
357    *old = current;
358               
359        return error;
360
361}  // end hal_remote_atomic_try_add()
362
363/////////////////////////////////////
364void hal_remote_memcpy( xptr_t   dst,
365                        xptr_t   src,
366                        uint32_t size )
367{
368    uint32_t save_sr;
369        uint32_t i;
370        uint32_t wsize;
371    uint32_t dptr = (uint32_t)GET_PTR( dst );
372    uint32_t dcxy = (uint32_t)GET_CXY( dst );
373    uint32_t sptr = (uint32_t)GET_PTR( src );
374    uint32_t scxy = (uint32_t)GET_CXY( src );
375
376    hal_disable_irq( &save_sr );
377
378        if( (dptr & 0x3) || (sptr & 0x3) ) wsize = 0;  // do it all in bytes
379    else                               wsize = size >> 2;
380
381        for( i = 0 ; i < wsize ; i++ )          // transfer one word per iteration
382        {
383        asm volatile( 
384            ".set noreorder              \n"
385            "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
386            "mtc2   %0,     $24          \n"  /* PADDR_EXT <= scxy    */   
387                    "lw     $3,     0(%1)            \n"  /* $3 <= *src           */                           
388            "mtc2   %2,     $24          \n"  /* PADDR_EXT <= dcxy    */       
389            "sw     $3,     0(%3)        \n"  /* *dst <= $3           */
390            "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
391            ".set reorder                \n"
392                    : : "r"(scxy), "r" (sptr+(i<<2)), "r"(dcxy), "r" (dptr+(i<<2)) : "$3", "$15" );             
393        }
394
395        for( i = wsize << 2 ; i < size ; i++ )  // transfer one byte per iteration
396        {
397        asm volatile( 
398            ".set noreorder              \n"
399            "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
400            "mtc2   %0,     $24          \n"  /* PADDR_EXT <= scxy    */   
401                    "lb         $3,     0(%1)        \n"  /* $3 <= *src           */                           
402            "mtc2   %2,     $24          \n"  /* PADDR_EXT <= dcxy    */       
403            "sb     $3,     0(%3)        \n"  /* *dst <= $3           */
404            "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
405            ".set reorder                \n"
406                    : : "r"(scxy), "r" (sptr+i), "r"(dcxy), "r" (dptr+i) : "$3", "$15" );               
407        }
408
409    hal_restore_irq( save_sr );
410
411}  // end hal_remote_memcpy()
412
413///////////////////////////////////
414void hal_remote_strcpy( xptr_t dst,
415                        xptr_t src )
416{
417    uint32_t save_sr;
418    uint32_t dptr = (uint32_t)GET_PTR( dst );
419    uint32_t dcxy = (uint32_t)GET_CXY( dst );
420    uint32_t sptr = (uint32_t)GET_PTR( src );
421    uint32_t scxy = (uint32_t)GET_CXY( src );
422
423    hal_disable_irq( &save_sr );
424
425    // loop on characters while non NUL
426    asm volatile(
427        "mfc2   $15,   $24          \n"   /* $15 <= PADDR_EXT               */
428        "1:                         \n"   /* loop entry                     */
429        "mtc2   %0,    $24          \n"   /* PADDR_EXT <= scxy              */   
430        "lb         $13,   0(%1)        \n"   /* read char from src string      */
431        "mtc2   %2,    $24          \n"   /* PADDR_EXT <= dcxy              */   
432            "sb     $13,   0(%3)        \n"   /* store char to dst string       */
433        "addi   %1,    %1,  1       \n"   /* increment sptr pointer         */
434        "addi   %3,    %3,  1       \n"   /* increment dptr pointer         */
435        "bne    $13,   $0,  1b      \n"   /* test NUL                       */
436        "nop                        \n"
437        "mtc2   $15,   $24          \n"   /* PADDR_EXT <= $15               */   
438        : : "r"(scxy), "r"(sptr), "r"(dcxy), "r"(dptr) : "$13","$15", "memory" );
439
440    hal_restore_irq( save_sr );
441
442} // end hal_remote_strcpy()
Note: See TracBrowser for help on using the repository browser.