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

Last change on this file since 610 was 610, checked in by alain, 5 years ago

Fix several bugs in VFS to support the following
ksh commandis : cp, mv, rm, mkdir, cd, pwd

File size: 18.7 KB
RevLine 
[1]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
[457]25#include <hal_kernel_types.h>
[204]26#include <hal_irqmask.h>
[501]27#include <hal_remote.h>
[1]28
29////////////////////////////////
30void hal_remote_sb( xptr_t   xp,
[72]31                    uint8_t  data )
[1]32{
33    uint32_t ptr = (uint32_t)GET_PTR( xp );
34    uint32_t cxy = (uint32_t)GET_CXY( xp );
35
[8]36    asm volatile( 
37        ".set noreorder              \n"
[279]38        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR      */
39        "srl    $13,    $14,    1    \n" 
40        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked   */
41        "mtc0   $13,    $12          \n"  /* IRQ disabled       */
42       
43        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */   
44        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
45        "sb     %0,     0(%1)        \n"  /* *paddr <= value    */
46        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
47
48        "mtc0   $14,    $12          \n"  /* SR restored        */
49
[8]50        "sync                        \n"
51        ".set reorder                \n"
[279]52        : : "r" (data), "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
[1]53}
54
55/////////////////////////////////
[570]56void hal_remote_s32( xptr_t    xp,
[1]57                    uint32_t  data )
58{
59    uint32_t ptr = (uint32_t)GET_PTR( xp );
60    uint32_t cxy = (uint32_t)GET_CXY( xp );
61
[296]62    asm volatile( 
63        ".set noreorder              \n"
64        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR      */
65        "srl    $13,    $14,    1    \n" 
66        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked   */
67        "mtc0   $13,    $12          \n"  /* IRQ disabled       */
[121]68
[296]69        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */   
70        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
71        "sw     %0,     0(%1)        \n"  /* *paddr <= value    */
72        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
73
74        "mtc0   $14,    $12          \n"  /* SR restored        */
75
[8]76        "sync                        \n"
77        ".set reorder                \n"
[296]78        : : "r" (data), "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
[1]79}
80
81//////////////////////////////////
[570]82void hal_remote_s64( xptr_t    xp,
[1]83                     uint64_t  data )
84{
85    uint32_t ptr = (uint32_t)GET_PTR( xp );
86    uint32_t cxy = (uint32_t)GET_CXY( xp );
87
88    uint32_t data_lsb = (uint32_t)data;
89    uint32_t data_msb = (uint32_t)(data>>32);
90
[8]91    asm volatile( 
92        ".set noreorder              \n"
[296]93        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR      */
94        "srl    $13,    $14,    1    \n" 
95        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked   */
96        "mtc0   $13,    $12          \n"  /* IRQ disabled       */
97
98        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */   
99        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy   */   
100        "sw     %0,     0(%2)        \n"  /* *paddr <= lsb      */
101        "sw     %1,     4(%2)        \n"  /* *(paddr+4) <= msb  */
102        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
103
104        "mtc0   $14,    $12          \n"  /* SR restored        */
105
[8]106        "sync                        \n"
107        ".set reorder                \n"
[296]108        : : "r" (data_lsb), "r" (data_msb), "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
[1]109}
110
111////////////////////////////////////
112void hal_remote_spt( xptr_t      xp,
113                     void *      pt )
114{
[570]115    hal_remote_s32 ( xp , (uint32_t)pt );
[1]116}
117
118////////////////////////////////
[72]119uint8_t hal_remote_lb( xptr_t  xp )
[1]120{
121        char     data;
122    uint32_t ptr = (uint32_t)GET_PTR( xp );
123    uint32_t cxy = (uint32_t)GET_CXY( xp );
124
[8]125    asm volatile( 
126        ".set noreorder              \n"
[296]127        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR      */
128        "srl    $13,    $14,    1    \n" 
129        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked   */
130        "mtc0   $13,    $12          \n"  /* IRQ disabled       */
131
[8]132        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */ 
133        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
134        "lb     %0,     0(%1)        \n"  /* data <= *paddr     */
135        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
[296]136
137        "mtc0   $14,    $12          \n"  /* SR restored        */
[8]138        ".set reorder                \n"
[296]139        : "=r" (data) : "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
[1]140
141        return ( data );
142}
143
144////////////////////////////////////
[570]145uint32_t hal_remote_l32( xptr_t  xp )
[1]146{
147        uint32_t data;
148    uint32_t ptr = (uint32_t)GET_PTR( xp );
149    uint32_t cxy = (uint32_t)GET_CXY( xp );
150
[8]151    asm volatile( 
152        ".set noreorder              \n"
[296]153        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR      */
154        "srl    $13,    $14,    1    \n" 
155        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked   */
156        "mtc0   $13,    $12          \n"  /* IRQ disabled       */
157
[8]158        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */ 
159        "mtc2   %2,     $24          \n"  /* PADDR_EXT <= cxy   */   
160        "lw     %0,     0(%1)        \n"  /* data <= *paddr     */
161        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
[296]162
163        "mtc0   $14,    $12          \n"  /* SR restored        */
[8]164        ".set reorder                \n"
[296]165        : "=r" (data) : "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
[1]166
167    return ( data );
168}
169
170/////////////////////////////////////
[570]171uint64_t hal_remote_l64( xptr_t  xp )
[1]172{
173    uint32_t data_lsb;
174    uint32_t data_msb;
175    uint32_t ptr = (uint32_t)GET_PTR( xp );
176    uint32_t cxy = (uint32_t)GET_CXY( xp );
177
[8]178    asm volatile( 
179        ".set noreorder              \n"
[296]180        "mfc0   $14,    $12          \n"  /* $14 <= CP0_SR        */
181        "srl    $13,    $14,    1    \n" 
182        "sll    $13,    $13,    1    \n"  /* $13 <= SR masked     */
183        "mtc0   $13,    $12          \n"  /* IRQ disabled         */
184
[8]185        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
186        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
187        "lw     %0,     0(%2)        \n"  /* data_lsb <= *paddr   */
188        "lw     %1,     4(%2)        \n"  /* data_msb <= *paddr+4 */
189        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
[296]190
191        "mtc0   $14,    $12          \n"  /* SR restored          */
[8]192        ".set reorder                \n"
[296]193        : "=r" (data_lsb), "=r"(data_msb) : "r" (ptr), "r" (cxy) : "$13", "$14", "$15" );
[1]194
195    return ( (((uint64_t)data_msb)<<32) + (((uint64_t)data_lsb)) );
[121]196
[1]197}
198
199////////////////////////////////////
[92]200void * hal_remote_lpt( xptr_t    xp )
[1]201{
[570]202    return (void *)hal_remote_l32 ( xp );
[1]203}
204
205///////////////////////////////////////////
206bool_t hal_remote_atomic_cas( xptr_t    xp,
207                              uint32_t  old,
208                              uint32_t  new )
209{
[121]210    uint32_t save_sr;
[1]211        bool_t   isAtomic;
212    uint32_t ptr = (uint32_t)GET_PTR( xp );
213    uint32_t cxy = (uint32_t)GET_CXY( xp );
214
[121]215    hal_disable_irq( &save_sr );
216
[8]217    asm volatile( 
218        ".set noreorder              \n"
219        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT   */ 
220        "mtc2   %4,     $24          \n"  /* PADDR_EXT <= cxy   */   
221        "or     $8,     $0,    %3    \n"  /* $8 <= new          */
222        "ll     $3,    0(%1)         \n"  /* $3 <= *paddr       */
223        "bne    $3,     %2,    1f    \n"  /* if ($3 != old)     */
224        "li     $7,     0            \n"  /* $7 <= 0            */
225        "sc     $8,     (%1)         \n"  /* *paddr <= new      */
226        "or     $7,     $8,    $0    \n"  /* $7 <= atomic       */
227        "sync                        \n"
228        "1:                          \n"
229        "or     %0,     $7,    $0    \n"  /* isAtomic <= $7     */
230        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15   */   
231        ".set reorder                \n"
232        : "=&r" (isAtomic) : "r" (ptr), "r" (old) , "r" (new), "r" (cxy) 
233                : "$3", "$7", "$8", "$15" );
[1]234
[121]235    hal_restore_irq( save_sr );
236
[1]237        return isAtomic;
238
[121]239}  // end hal_remote_atomic_cas()
240
[1]241////////////////////////////////////////////
242uint32_t hal_remote_atomic_add( xptr_t   xp, 
243                                uint32_t incr )
244{       
[121]245    uint32_t save_sr;
[1]246        uint32_t current;
247    uint32_t ptr = (uint32_t)GET_PTR( xp );
248    uint32_t cxy = (uint32_t)GET_CXY( xp );
249
[121]250    hal_disable_irq( &save_sr );
251
[8]252    asm volatile( 
253        ".set noreorder              \n"
254        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
255        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
256        "1:                          \n"
257        "ll     %0,     (%1)         \n"  /* current <= *paddr    */
258        "addu   $3,     %0,     %2   \n"  /* $3 <= current + incr */
259        "sc     $3,     (%1)         \n"  /* *paddr <= $3         */
260        "beq    $3,     $0,     1b   \n"  /* retry if failure     */
261        "nop                         \n"
262        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
263        ".set reorder                \n"
264                : "=&r" (current) : "r" (ptr), "r" (incr), "r" (cxy) : "$3", "$15" );
[1]265
[121]266    hal_restore_irq( save_sr );
267
[1]268        return current;
269
[121]270}  // end hal_remote_atomic_add()
271
[1]272////////////////////////////////////////////
273uint32_t hal_remote_atomic_and( xptr_t   xp, 
274                                uint32_t mask )
275{       
[121]276    uint32_t save_sr;
[1]277        uint32_t current;
278    uint32_t ptr = (uint32_t)GET_PTR( xp );
279    uint32_t cxy = (uint32_t)GET_CXY( xp );
280
[121]281    hal_disable_irq( &save_sr );
282
[8]283    asm volatile( 
284        ".set noreorder              \n"
285        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
286        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
287        "1:                          \n"
288        "ll     %0,     (%1)         \n"  /* current <= *paddr    */
289        "and    $3,     %0,     %2   \n"  /* $3 <= current & mask */
290        "sc     $3,     (%1)         \n"  /* *paddr <= $3         */
291        "beq    $3,     $0,     1b   \n"  /* retry if failure     */
292        "nop                         \n"
293        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
294        ".set reorder                \n"
295            : "=&r" (current) : "r" (ptr), "r" (mask), "r" (cxy) : "$3", "$15" );
[1]296
[121]297    hal_restore_irq( save_sr );
298
[1]299        return current;
300
[121]301}  // end hal_remote_atomic_and()
302
[1]303////////////////////////////////////////////
304uint32_t hal_remote_atomic_or( xptr_t   xp, 
305                               uint32_t mask )
306{       
[121]307    uint32_t save_sr;
[1]308        uint32_t current;
309    uint32_t ptr = (uint32_t)GET_PTR( xp );
310    uint32_t cxy = (uint32_t)GET_CXY( xp );
311
[121]312    hal_disable_irq( &save_sr );
313
[8]314    asm volatile( 
315        ".set noreorder              \n"
316        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
317        "mtc2   %3,     $24          \n"  /* PADDR_EXT <= cxy     */   
318        "1:                          \n"
319        "ll     %0,     (%1)         \n"  /* current <= *paddr    */
320        "or     $3,     %0,     %2   \n"  /* $3 <= current | mask */
321        "sc     $3,     (%1)         \n"  /* *paddr <= $3         */
322        "beq    $3,     $0,     1b   \n"  /* retry if failure     */
323        "nop                         \n"
324        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
325        ".set reorder                \n"
326            : "=&r" (current) : "r" (ptr), "r" (mask), "r" (cxy) : "$3", "$15" );
[1]327
[121]328    hal_restore_irq( save_sr );
329
[1]330        return current;
331
[121]332}  // end hal_remote_atomic_or()
333
[1]334/////////////////////////////////////////////////
335error_t hal_remote_atomic_try_add( xptr_t     xp,
336                                   uint32_t   incr,
337                                   uint32_t * old )
338{
[121]339    uint32_t save_sr;
[1]340        uint32_t current;
341        error_t  error;
342    uint32_t ptr = (uint32_t)GET_PTR( xp );
343    uint32_t cxy = (uint32_t)GET_CXY( xp );
344
[121]345    hal_disable_irq( &save_sr );
346
[8]347    asm volatile( 
348        ".set noreorder              \n"
349        "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
350        "mtc2   %4,     $24          \n"  /* PADDR_EXT <= cxy     */   
351        "ll     %0,     (%2)         \n"  /* current <= *paddr    */
352        "addu   $3,     %0,     %3   \n"  /* $3 <= current + incr */
353        "sc     $3,     (%2)         \n"  /* *paddr <= $3         */
354        "beq    $3,     $0,     1f   \n"  /* exit if failure      */
[121]355        "ori    %1,     $0,      1   \n"  /* fail: ret <= 1       */
356        "and    %1,     $0,     $0   \n"  /* success: ret <= 0    */
[8]357        "1:                          \n"
358        "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
359        ".set reorder                \n"
360                : "=&r" (current), "=&r" (error) : "r" (ptr), "r" (incr), "r" (cxy) : "$3", "$15" );
[1]361               
[121]362    hal_restore_irq( save_sr );
363
[1]364    *old = current;
365               
366        return error;
367
[121]368}  // end hal_remote_atomic_try_add()
369
[1]370/////////////////////////////////////
371void hal_remote_memcpy( xptr_t   dst,
372                        xptr_t   src,
373                        uint32_t size )
374{
[121]375    uint32_t save_sr;
[1]376        uint32_t i;
377        uint32_t wsize;
378    uint32_t dptr = (uint32_t)GET_PTR( dst );
379    uint32_t dcxy = (uint32_t)GET_CXY( dst );
380    uint32_t sptr = (uint32_t)GET_PTR( src );
381    uint32_t scxy = (uint32_t)GET_CXY( src );
382
[610]383/*
384if( local_cxy == 1 )
385printk("\n@@@ %s : scxy %x / sptr %x / dcxy %x / dptr %x\n",
386__FUNCTION__, scxy, sptr, dcxy, dptr );
387*/
[121]388    hal_disable_irq( &save_sr );
389
[1]390        if( (dptr & 0x3) || (sptr & 0x3) ) wsize = 0;  // do it all in bytes
391    else                               wsize = size >> 2;
392
393        for( i = 0 ; i < wsize ; i++ )          // transfer one word per iteration
394        {
[8]395        asm volatile( 
396            ".set noreorder              \n"
397            "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
398            "mtc2   %0,     $24          \n"  /* PADDR_EXT <= scxy    */   
399                    "lw     $3,     0(%1)            \n"  /* $3 <= *src           */                           
400            "mtc2   %2,     $24          \n"  /* PADDR_EXT <= dcxy    */       
401            "sw     $3,     0(%3)        \n"  /* *dst <= $3           */
402            "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
403            ".set reorder                \n"
404                    : : "r"(scxy), "r" (sptr+(i<<2)), "r"(dcxy), "r" (dptr+(i<<2)) : "$3", "$15" );             
[1]405        }
406
407        for( i = wsize << 2 ; i < size ; i++ )  // transfer one byte per iteration
408        {
[8]409        asm volatile( 
410            ".set noreorder              \n"
411            "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
412            "mtc2   %0,     $24          \n"  /* PADDR_EXT <= scxy    */   
413                    "lb         $3,     0(%1)        \n"  /* $3 <= *src           */                           
414            "mtc2   %2,     $24          \n"  /* PADDR_EXT <= dcxy    */       
415            "sb     $3,     0(%3)        \n"  /* *dst <= $3           */
416            "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
417            ".set reorder                \n"
418                    : : "r"(scxy), "r" (sptr+i), "r"(dcxy), "r" (dptr+i) : "$3", "$15" );               
[1]419        }
420
[121]421    hal_restore_irq( save_sr );
[1]422
[121]423}  // end hal_remote_memcpy()
424
425///////////////////////////////////
426void hal_remote_strcpy( xptr_t dst,
427                        xptr_t src )
428{
429    uint32_t save_sr;
430    uint32_t dptr = (uint32_t)GET_PTR( dst );
431    uint32_t dcxy = (uint32_t)GET_CXY( dst );
432    uint32_t sptr = (uint32_t)GET_PTR( src );
433    uint32_t scxy = (uint32_t)GET_CXY( src );
434
435    hal_disable_irq( &save_sr );
436
437    // loop on characters while non NUL
438    asm volatile(
439        "mfc2   $15,   $24          \n"   /* $15 <= PADDR_EXT               */
440        "1:                         \n"   /* loop entry                     */
441        "mtc2   %0,    $24          \n"   /* PADDR_EXT <= scxy              */   
442        "lb         $13,   0(%1)        \n"   /* read char from src string      */
443        "mtc2   %2,    $24          \n"   /* PADDR_EXT <= dcxy              */   
444            "sb     $13,   0(%3)        \n"   /* store char to dst string       */
445        "addi   %1,    %1,  1       \n"   /* increment sptr pointer         */
446        "addi   %3,    %3,  1       \n"   /* increment dptr pointer         */
447        "bne    $13,   $0,  1b      \n"   /* test NUL                       */
448        "nop                        \n"
449        "mtc2   $15,   $24          \n"   /* PADDR_EXT <= $15               */   
450        : : "r"(scxy), "r"(sptr), "r"(dcxy), "r"(dptr) : "$13","$15", "memory" );
451
452    hal_restore_irq( save_sr );
453
454} // end hal_remote_strcpy()
[313]455
456////////////////////////////////////////
457void hal_remote_memset( xptr_t   buf_xp,
458                        uint8_t  byte,
459                        uint32_t size )
460{
461    uint32_t save_sr;
462        uint32_t i;
463        uint32_t wsize;
464    uint32_t buf_ptr = (uint32_t)GET_PTR( buf_xp );
465    uint32_t buf_cxy = (uint32_t)GET_CXY( buf_xp );
466    uint32_t word    = ((uint32_t)byte)<<24 |
467                       ((uint32_t)byte)<<16 |
468                       ((uint32_t)byte)<<8  |
469                       ((uint32_t)byte)     ;
470
471    hal_disable_irq( &save_sr );
472
473        if( (buf_ptr & 0x3) ) wsize = 0;  // do it all in bytes
474    else                  wsize = size >> 2;
475
476        for( i = 0 ; i < wsize ; i++ )          // transfer one word per iteration
477        {
478        asm volatile( 
479            ".set noreorder              \n"
480            "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
481            "mtc2   %0,     $24          \n"  /* PADDR_EXT <= buf_cxy */   
482            "sw     %2,     0(%1)        \n"  /* set one word         */
483            "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
484            ".set reorder                \n"
485                    : : "r"(buf_cxy), "r" (buf_ptr+(i<<2)), "r"(byte) : "$15" );               
486        }
487
488        for( i = wsize << 2 ; i < size ; i++ )  // transfer one byte per iteration
489        {
490        asm volatile( 
491            ".set noreorder              \n"
492            "mfc2   $15,    $24          \n"  /* $15 <= PADDR_EXT     */ 
493            "mtc2   %0,     $24          \n"  /* PADDR_EXT <= buf_cxy */   
494            "sb     %2,     0(%1)        \n"  /* set one byte         */
495            "mtc2   $15,    $24          \n"  /* PADDR_EXT <= $15     */   
496            ".set reorder                \n"
497                    : : "r"(buf_cxy), "r"(buf_ptr+i), "r"(word) : "$15" );             
498        }
499
500    hal_restore_irq( save_sr );
501
502}  // end hal_remote_memset()
503
Note: See TracBrowser for help on using the repository browser.