qemu/roms/openbios/arch/ppc/qemu/methods.c

   1 /*
   2  *   Creation Date: <2004/08/28 18:38:22 greg>
   3  *   Time-stamp: <2004/08/28 18:38:22 greg>
   4  *
   5  *      <methods.c>
   6  *
   7  *      Misc device node methods
   8  *
   9  *   Copyright (C) 2004 Greg Watson
  10  *
  11  *   Based on MOL specific code which is
  12  *
  13  *   Copyright (C) 2003, 2004 Samuel Rydh (samuel@ibrium.se)
  14  *
  15  *   This program is free software; you can redistribute it and/or
  16  *   modify it under the terms of the GNU General Public License
  17  *   version 2
  18  *
  19  */
  20
  21 #include "config.h"
  22 #include "libopenbios/bindings.h"
  23 #include "drivers/drivers.h"
  24 #include "libc/string.h"
  25 #include "qemu/qemu.h"
  26 #include "libopenbios/ofmem.h"
  27 #include "arch/ppc/processor.h"
  28 #include "drivers/usb.h"
  29
  30 /************************************************************************/
  31 /*      RTAS (run-time abstraction services)                            */
  32 /************************************************************************/
  33
  34 #ifdef CONFIG_RTAS
  35 DECLARE_NODE( rtas, INSTALL_OPEN, 0, "+/rtas" );
  36
  37 /* ( physbase -- rtas_callback ) */
  38 static void
  39 rtas_instantiate( void )
  40 {
  41         ucell physbase = POP();
  42         ucell s=0x1000, size = (ucell)of_rtas_end - (ucell)of_rtas_start;
  43         unsigned long virt;
  44
  45         while( s < size )
  46                 s += 0x1000;
  47         virt = ofmem_claim_virt( 0, s, 0x1000 );
  48         ofmem_map( physbase, virt, s, -1 );
  49         memcpy( (char*)virt, of_rtas_start, size );
  50
  51         printk("RTAS instantiated at %08x\n", physbase );
  52         flush_icache_range( (char*)virt, (char*)virt + size );
  53
  54         PUSH( physbase );
  55 }
  56
  57 NODE_METHODS( rtas ) = {
  58         { "instantiate",        rtas_instantiate },
  59         { "instantiate-rtas",   rtas_instantiate },
  60 };
  61 #endif
  62
  63
  64 /************************************************************************/
  65 /*      tty                                                             */
  66 /************************************************************************/
  67
  68 DECLARE_NODE( tty, INSTALL_OPEN, 0, "/packages/terminal-emulator" );
  69
  70 /* ( addr len -- actual ) */
  71 static void
  72 tty_read( void )
  73 {
  74         int ch, len = POP();
  75         char *p = (char*)cell2pointer(POP());
  76         int ret=0;
  77
  78         if( len > 0 ) {
  79                 ret = 1;
  80                 ch = getchar();
  81                 if( ch >= 0 ) {
  82                         *p = ch;
  83                 } else {
  84                         ret = 0;
  85                 }
  86         }
  87         PUSH( ret );
  88 }
  89
  90 /* ( addr len -- actual ) */
  91 static void
  92 tty_write( void )
  93 {
  94         int i, len = POP();
  95         char *p = (char*)cell2pointer(POP());
  96         for( i=0; i<len; i++ )
  97                 putchar( *p++ );
  98         RET( len );
  99 }
 100
 101 NODE_METHODS( tty ) = {
 102         { "read",       tty_read        },
 103         { "write",      tty_write       },
 104 };
 105
 106 /************************************************************************/
 107 /*      client interface 'quiesce'                                      */
 108 /************************************************************************/
 109
 110 DECLARE_NODE( ciface, 0, 0, "+/openprom/client-services" );
 111
 112 /* ( -- ) */
 113 static void
 114 ciface_quiesce( unsigned long args[], unsigned long ret[] )
 115 {
 116         usb_exit();
 117 #if 0
 118         unsigned long msr;
 119         /* This seems to be the correct thing to do - but I'm not sure */
 120         asm volatile("mfmsr %0" : "=r" (msr) : );
 121         msr &= ~(MSR_IR | MSR_DR);
 122         asm volatile("mtmsr %0" :: "r" (msr) );
 123 #endif
 124 }
 125
 126 /* ( -- ms ) */
 127 #define TIMER_FREQUENCY 16600000ULL
 128
 129 static void
 130 ciface_milliseconds( unsigned long args[], unsigned long ret[] )
 131 {
 132         unsigned long tbu, tbl, temp;
 133         unsigned long long ticks, msecs;
 134
 135         asm volatile(
 136                 "1:\n"
 137                 "mftbu  %2\n"
 138                 "mftb   %0\n"
 139                 "mftbu  %1\n"
 140                 "cmpw   %2,%1\n"
 141                 "bne    1b\n"
 142                 : "=r"(tbl), "=r"(tbu), "=r"(temp)
 143                 :
 144                 : "cc");
 145
 146         ticks = (((unsigned long long)tbu) << 32) | (unsigned long long)tbl;
 147         msecs = (1000 * ticks) / TIMER_FREQUENCY;
 148         PUSH( msecs );
 149 }
 150
 151
 152 NODE_METHODS( ciface ) = {
 153         { "quiesce",            ciface_quiesce          },
 154         { "milliseconds",       ciface_milliseconds     },
 155 };
 156
 157
 158 /************************************************************************/
 159 /*      MMU/memory methods                                              */
 160 /************************************************************************/
 161
 162 DECLARE_NODE( memory, INSTALL_OPEN, 0, "/memory" );
 163 DECLARE_UNNAMED_NODE( mmu, INSTALL_OPEN, 0 );
 164 DECLARE_NODE( mmu_ciface, 0, 0, "+/openprom/client-services" );
 165
 166
 167 /* ( phys size align --- base ) */
 168 static void
 169 mem_claim( void )
 170 {
 171         ucell align = POP();
 172         ucell size = POP();
 173         ucell phys = POP();
 174         ucell ret = ofmem_claim_phys( phys, size, align );
 175
 176         if( ret == -1 ) {
 177                 printk("MEM: claim failure\n");
 178                 throw( -13 );
 179                 return;
 180         }
 181         PUSH( ret );
 182 }
 183
 184 /* ( phys size --- ) */
 185 static void
 186 mem_release( void )
 187 {
 188         POP(); POP();
 189 }
 190
 191 /* ( phys size align --- base ) */
 192 static void
 193 mmu_claim( void )
 194 {
 195         ucell align = POP();
 196         ucell size = POP();
 197         ucell phys = POP();
 198         ucell ret = ofmem_claim_virt( phys, size, align );
 199
 200         if( ret == -1 ) {
 201                 printk("MMU: CLAIM failure\n");
 202                 throw( -13 );
 203                 return;
 204         }
 205         PUSH( ret );
 206 }
 207
 208 /* ( phys size --- ) */
 209 static void
 210 mmu_release( void )
 211 {
 212         POP(); POP();
 213 }
 214
 215 /* ( phys virt size mode -- [ret???] ) */
 216 static void
 217 mmu_map( void )
 218 {
 219         ucell mode = POP();
 220         ucell size = POP();
 221         ucell virt = POP();
 222         ucell phys = POP();
 223         ucell ret;
 224
 225         /* printk("mmu_map: %x %x %x %x\n", phys, virt, size, mode ); */
 226         ret = ofmem_map( phys, virt, size, mode );
 227
 228         if( ret ) {
 229                 printk("MMU: map failure\n");
 230                 throw( -13 );
 231                 return;
 232         }
 233 }
 234
 235 /* ( virt size -- ) */
 236 static void
 237 mmu_unmap( void )
 238 {
 239         POP(); POP();
 240 }
 241
 242 /* ( virt -- false | phys mode true ) */
 243 static void
 244 mmu_translate( void )
 245 {
 246         ucell mode;
 247         ucell virt = POP();
 248         ucell phys = ofmem_translate( virt, &mode );
 249
 250         if( phys == -1 ) {
 251                 PUSH( 0 );
 252         } else {
 253                 PUSH( phys );
 254                 PUSH( mode );
 255                 PUSH( -1 );
 256         }
 257 }
 258
 259 /* ( virt size align -- baseaddr|-1 ) */
 260 static void
 261 ciface_claim( void )
 262 {
 263         ucell align = POP();
 264         ucell size = POP();
 265         ucell virt = POP();
 266         ucell ret = ofmem_claim( virt, size, align );
 267
 268         /* printk("ciface_claim: %08x %08x %x\n", virt, size, align ); */
 269         PUSH( ret );
 270 }
 271
 272 /* ( virt size -- ) */
 273 static void
 274 ciface_release( void )
 275 {
 276         ucell size = POP();
 277         ucell virt = POP();
 278         ofmem_release(virt, size);
 279 }
 280
 281
 282 NODE_METHODS( memory ) = {
 283         { "claim",              mem_claim               },
 284         { "release",            mem_release             },
 285 };
 286
 287 NODE_METHODS( mmu ) = {
 288         { "claim",              mmu_claim               },
 289         { "release",            mmu_release             },
 290         { "map",                mmu_map                 },
 291         { "unmap",              mmu_unmap               },
 292         { "translate",          mmu_translate           },
 293 };
 294
 295 NODE_METHODS( mmu_ciface ) = {
 296         { "cif-claim",          ciface_claim            },
 297         { "cif-release",        ciface_release          },
 298 };
 299
 300
 301 /************************************************************************/
 302 /*      init                                                            */
 303 /************************************************************************/
 304
 305 void
 306 node_methods_init( const char *cpuname )
 307 {
 308         phandle_t chosen, ph;
 309 #ifdef CONFIG_RTAS
 310         if (is_newworld()) {
 311                 REGISTER_NODE( rtas );
 312         }
 313 #endif
 314         REGISTER_NODE( ciface );
 315         REGISTER_NODE( memory );
 316         REGISTER_NODE_METHODS( mmu, cpuname );
 317         REGISTER_NODE( mmu_ciface );
 318         REGISTER_NODE( tty );
 319
 320         chosen = find_dev("/chosen");
 321         if (chosen) {
 322                 push_str(cpuname);
 323                 fword("open-dev");
 324                 ph = POP();
 325                 set_int_property(chosen, "mmu", ph);
 326         }
 327 }