ee_core/src/modmgr.c

   1 /*
   2   Copyright 2009-2010, Ifcaro, jimmikaelkael & Polo
   3   Copyright 2006-2008 Polo
   4   Licenced under Academic Free License version 3.0
   5   Review OpenUsbLd README & LICENSE files for further details.
   6
   7   Some parts of the code are taken from HD Project by Polo
   8 */
   9
  10 #include "ee_core.h"
  11 #include "modmgr.h"
  12 #include "util.h"
  13
  14 void *imgdrv_irx;
  15 int size_imgdrv_irx;
  16
  17 void *eesync_irx;
  18 int size_eesync_irx;
  19
  20 void *cdvdman_irx;
  21 int size_cdvdman_irx;
  22
  23 void *cdvdfsv_irx;
  24 int size_cdvdfsv_irx;
  25
  26 void *cddev_irx;
  27 int size_cddev_irx;
  28
  29 #ifdef VMC
  30 void *mcemu_irx;
  31 int size_mcemu_irx;
  32 #endif
  33
  34 void *usbd_irx;
  35 int size_usbd_irx;
  36
  37 void *ps2dev9_irx;
  38 int size_ps2dev9_irx;
  39
  40 void *smstcpip_irx;
  41 int size_smstcpip_irx;
  42
  43 void *smsmap_irx;
  44 int size_smsmap_irx;
  45
  46 void *udptty_irx;
  47 int size_udptty_irx;
  48
  49 void *ioptrap_irx;
  50 int size_ioptrap_irx;
  51
  52 void *smbman_irx;
  53 int size_smbman_irx;
  54
  55 static SifRpcClientData_t _lf_cd;
  56 static int _lf_init  = 0;
  57
  58 typedef struct {
  59         void *irxaddr;
  60         int irxsize;
  61 } irxptr_t;
  62
  63 /*----------------------------------------------------------------------------------------*/
  64 /* Init LOADFILE RPC.                                                                     */
  65 /*----------------------------------------------------------------------------------------*/
  66 int LoadFileInit()
  67 {
  68         int r;
  69
  70         if (_lf_init)
  71                 return 0;
  72
  73         while ((r = SifBindRpc(&_lf_cd, 0x80000006, 0)) >= 0 && (!_lf_cd.server))
  74                 nopdelay();
  75
  76         if (r < 0)
  77                 return -E_SIF_RPC_BIND;
  78
  79         _lf_init = 1;
  80
  81         return 0;
  82 }
  83
  84
  85 /*----------------------------------------------------------------------------------------*/
  86 /* DeInit LOADFILE RPC.                                                                   */
  87 /*----------------------------------------------------------------------------------------*/
  88 void LoadFileExit()
  89 {
  90         _lf_init = 0;
  91         memset(&_lf_cd, 0, sizeof(_lf_cd));
  92 }
  93
  94
  95 /*----------------------------------------------------------------------------------------*/
  96 /* Load an irx module from path with waiting.                                             */
  97 /*----------------------------------------------------------------------------------------*/
  98 int LoadModule(const char *path, int arg_len, const char *args)
  99 {
 100         struct _lf_module_load_arg arg;
 101
 102         if (LoadFileInit() < 0)
 103                 return -E_LIB_API_INIT;
 104
 105         memset(&arg, 0, sizeof arg);
 106
 107         strncpy(arg.path, path, LF_PATH_MAX - 1);
 108         arg.path[LF_PATH_MAX - 1] = 0;
 109
 110         if ((args) && (arg_len))
 111         {
 112                 arg.p.arg_len = arg_len > LF_ARG_MAX ? LF_ARG_MAX : arg_len;
 113                 memcpy(arg.args, args, arg.p.arg_len);
 114         }
 115         else arg.p.arg_len = 0;
 116
 117         if (SifCallRpc(&_lf_cd, LF_F_MOD_LOAD, 0x0, &arg, sizeof(arg), &arg, 8, NULL, NULL) < 0)
 118                 return -E_SIF_RPC_CALL;
 119
 120         return arg.p.result;
 121 }
 122
 123
 124 /*----------------------------------------------------------------------------------------*/
 125 /* Load an irx module from path without waiting.                                          */
 126 /*----------------------------------------------------------------------------------------*/
 127 int LoadModuleAsync(const char *path, int arg_len, const char *args)
 128 {
 129         struct _lf_module_load_arg arg;
 130
 131         if (LoadFileInit() < 0)
 132                 return -E_LIB_API_INIT;
 133
 134         memset(&arg, 0, sizeof arg);
 135
 136         strncpy(arg.path, path, LF_PATH_MAX - 1);
 137         arg.path[LF_PATH_MAX - 1] = 0;
 138
 139         if ((args) && (arg_len))
 140         {
 141                 arg.p.arg_len = arg_len > LF_ARG_MAX ? LF_ARG_MAX : arg_len;
 142                 memcpy(arg.args, args, arg.p.arg_len);
 143         }
 144         else arg.p.arg_len = 0;
 145
 146         if (SifCallRpc(&_lf_cd, LF_F_MOD_LOAD, SIF_RPC_M_NOWAIT, &arg, sizeof(arg), &arg, 8, NULL, NULL) < 0)
 147                 return -E_SIF_RPC_CALL;
 148
 149         return 0;
 150 }
 151
 152 #ifdef VMC
 153 #define IRX_NUM 11
 154 #else
 155 #define IRX_NUM 10
 156 #endif
 157
 158 //--------------------------------------------------------------
 159 void GetIrxKernelRAM(void) // load needed modules from the kernel ram
 160 {
 161         int n;
 162         irxptr_t irxptr_tab[IRX_NUM];
 163
 164         DIntr();
 165         ee_kmode_enter();
 166
 167         void *irx_tab = (void *)(*(u32 *)0x80033000);
 168         memcpy(&irxptr_tab[0], irx_tab, sizeof(irxptr_tab));
 169
 170         ee_kmode_exit();
 171         EIntr();
 172
 173         n = 0;
 174         size_imgdrv_irx = irxptr_tab[n++].irxsize;
 175         size_eesync_irx = irxptr_tab[n++].irxsize;
 176         size_cdvdman_irx = irxptr_tab[n++].irxsize;
 177         size_cdvdfsv_irx = irxptr_tab[n++].irxsize;
 178         size_cddev_irx = irxptr_tab[n++].irxsize;
 179         size_usbd_irx = irxptr_tab[n++].irxsize;
 180         size_smsmap_irx = irxptr_tab[n++].irxsize;
 181         size_udptty_irx = irxptr_tab[n++].irxsize;
 182         size_ioptrap_irx = irxptr_tab[n++].irxsize;
 183         size_smstcpip_irx = irxptr_tab[n++].irxsize;
 184 #ifdef VMC
 185         size_mcemu_irx = irxptr_tab[n++].irxsize;
 186 #endif
 187
 188         n = 0;
 189         imgdrv_irx = (void *)irxptr_tab[n++].irxaddr;
 190         eesync_irx = (void *)irxptr_tab[n++].irxaddr;
 191         cdvdman_irx = (void *)irxptr_tab[n++].irxaddr;
 192         cdvdfsv_irx = (void *)irxptr_tab[n++].irxaddr;
 193         cddev_irx = (void *)irxptr_tab[n++].irxaddr;
 194         usbd_irx = (void *)irxptr_tab[n++].irxaddr;
 195         smsmap_irx = (void *)irxptr_tab[n++].irxaddr;
 196         udptty_irx = (void *)irxptr_tab[n++].irxaddr;
 197         ioptrap_irx = (void *)irxptr_tab[n++].irxaddr;
 198         smstcpip_irx = (void *)irxptr_tab[n++].irxaddr;
 199 #ifdef VMC
 200         mcemu_irx = (void *)irxptr_tab[n++].irxaddr;
 201 #endif
 202 }
 203
 204 // ------------------------------------------------------------------------
 205 int LoadIRXfromKernel(void *irxkernelmem, int irxsize, int arglen, char *argv)
 206 {
 207         DIntr();
 208         ee_kmode_enter();
 209
 210         memcpy(g_buf, irxkernelmem, irxsize);
 211
 212         ee_kmode_exit();
 213         EIntr();
 214
 215         return LoadMemModule(g_buf, irxsize, arglen, argv);
 216 }
 217
 218 /*----------------------------------------------------------------------------------------*/
 219 /* Load an irx module from a EE buffer.                                                   */
 220 /*----------------------------------------------------------------------------------------*/
 221 int LoadMemModule(void *modptr, unsigned int modsize, int arg_len, const char *args)
 222 {
 223         SifDmaTransfer_t sifdma;
 224         void            *iopmem;
 225         int              dma_id;
 226
 227         if (LoadFileInit() < 0)
 228                 return -E_LIB_API_INIT;
 229
 230         /* Round the size up to the nearest 16 bytes. */
 231         // modsize = (modsize + 15) & -16;
 232
 233         iopmem = SifAllocIopHeap(modsize);
 234         if (iopmem == NULL) return -E_IOP_NO_MEMORY;
 235
 236         sifdma.src  = modptr;
 237         sifdma.dest = iopmem;
 238         sifdma.size = modsize;
 239         sifdma.attr = 0;
 240
 241         SifWriteBackDCache(modptr, modsize);
 242
 243         do
 244         {
 245                 dma_id = SifSetDma(&sifdma, 1);
 246         } while (!dma_id);
 247
 248         while (SifDmaStat(dma_id) >= 0) {;}
 249
 250         struct _lf_module_buffer_load_arg arg;
 251
 252         memset(&arg, 0, sizeof arg);
 253
 254         arg.p.ptr = iopmem;
 255         if ((args) && (arg_len))
 256         {
 257                 arg.q.arg_len = arg_len > LF_ARG_MAX ? LF_ARG_MAX : arg_len;
 258                 memcpy(arg.args, args, arg.q.arg_len);
 259         }
 260         else arg.q.arg_len = 0;
 261
 262         if (SifCallRpc(&_lf_cd, LF_F_MOD_BUF_LOAD, 0, &arg, sizeof(arg), &arg, 8, NULL, NULL) < 0)
 263                 return -E_SIF_RPC_CALL;
 264
 265         SifFreeIopHeap(iopmem);
 266
 267         return arg.p.result;
 268 }
 269
 270 /*----------------------------------------------------------------------------------------*/
 271 /* Load an elf file from EE buffer.                                                       */
 272 /*----------------------------------------------------------------------------------------*/
 273 int LoadElf(const char *path, t_ExecData *data)
 274 {
 275         struct _lf_elf_load_arg arg;
 276
 277         if (LoadFileInit() < 0)
 278                 return -E_LIB_API_INIT;
 279
 280         u32 secname = 0x6c6c61;  /* "all" */
 281
 282         strncpy(arg.path, path, LF_PATH_MAX - 1);
 283         strncpy(arg.secname, (char*)&secname, LF_ARG_MAX - 1);
 284         arg.path[LF_PATH_MAX - 1] = 0;
 285         arg.secname[LF_ARG_MAX - 1] = 0;
 286
 287         if (SifCallRpc(&_lf_cd, LF_F_ELF_LOAD, 0, &arg, sizeof arg, &arg, sizeof(t_ExecData), NULL, NULL) < 0)
 288                 return -E_SIF_RPC_CALL;
 289
 290         if (arg.p.result < 0)
 291                 return arg.p.result;
 292
 293         if (data) {
 294                 data->epc = arg.p.epc;
 295                 data->gp  = arg.gp;
 296         }
 297
 298         return 0;
 299 }
 300
 301 /*----------------------------------------------------------------------------------------*/
 302 /* Find and change a module name.                                                         */
 303 /*----------------------------------------------------------------------------------------*/
 304 void ChangeModuleName(const char *name, const char *newname)
 305 {
 306         u8 search_name[60];
 307         smod_mod_info_t info;
 308
 309         if (!smod_get_next_mod(0, &info))
 310                 return;
 311
 312         int len = strlen(name);
 313
 314         do {
 315                 smem_read(info.name, search_name, sizeof(search_name));
 316
 317                 if (!_memcmp(search_name, name, len)) {
 318                         strncpy(search_name, newname, sizeof(search_name));
 319                         search_name[sizeof(search_name)-1] = 0;
 320                         smem_write(info.name, search_name, strlen(search_name));
 321                         break;
 322                 }
 323         } while (smod_get_next_mod(&info, &info));
 324
 325         FlushCache(0);
 326 }
 327
 328 /*----------------------------------------------------------------------------------------*/
 329 /* List modules currently loaded in the system.                                           */
 330 /*----------------------------------------------------------------------------------------*/
 331 #ifdef __EESIO_DEBUG
 332 void ListModules(void)
 333 {
 334         int c = 0;
 335         smod_mod_info_t info;
 336         u8 name[60];
 337
 338         if (!smod_get_next_mod(0, &info))
 339                 return;
 340         DPRINTF("List of modules currently loaded in the system:\n");
 341         do {
 342                 smem_read(info.name, name, sizeof name);
 343                 if (!(c & 1)) DPRINTF(" ");
 344                 DPRINTF("   %-21.21s  %2d  %3x%c", name, info.id, info.version, (++c & 1) ? ' ' : '\n');
 345         } while (smod_get_next_mod(&info, &info));
 346 }
 347 #endif
 348