gp2x/soc_mmsp2.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <math.h>
   5 #include <sys/types.h>
   6 #include <sys/stat.h>
   7 #include <fcntl.h>
   8 #include <sys/mman.h>
   9 #include <unistd.h>
  10
  11 #include "soc.h"
  12 #include "soc_mmsp2.h"
  13 #include "plat_gp2x.h"
  14 #include "../common/emu.h"
  15 #include "../common/arm_utils.h"
  16 #include "940ctl.h"
  17
  18 volatile unsigned short *gp2x_memregs;
  19 volatile unsigned long  *gp2x_memregl;
  20 extern void *gp2x_screens[4];
  21 static int screensel = 0;
  22
  23 int memdev = 0; /* used by code940 */
  24 static int touchdev = -1;
  25 static int touchcal[7] = { 6203, 0, -1501397, 0, -4200, 16132680, 65536 };
  26
  27 #define FRAMEBUFF_SIZE  0x30000
  28 #define FRAMEBUFF_WHOLESIZE (FRAMEBUFF_SIZE*4) // 320*240*2 + some more
  29 #define FRAMEBUFF_ADDR0 (0x4000000 - FRAMEBUFF_WHOLESIZE)
  30 #define FRAMEBUFF_ADDR1 (FRAMEBUFF_ADDR0 + FRAMEBUFF_SIZE)
  31 #define FRAMEBUFF_ADDR2 (FRAMEBUFF_ADDR1 + FRAMEBUFF_SIZE)
  32 #define FRAMEBUFF_ADDR3 (FRAMEBUFF_ADDR2 + FRAMEBUFF_SIZE)
  33
  34 static const int gp2x_screenaddrs[4] = { FRAMEBUFF_ADDR0, FRAMEBUFF_ADDR1, FRAMEBUFF_ADDR2, FRAMEBUFF_ADDR3 };
  35 static int gp2x_screenaddrs_use[4];
  36 static unsigned short gp2x_screenaddr_old[4];
  37
  38
  39 /* video stuff */
  40 void gp2x_video_flip(void)
  41 {
  42         unsigned short lsw = (unsigned short) gp2x_screenaddrs_use[screensel&3];
  43         unsigned short msw = (unsigned short)(gp2x_screenaddrs_use[screensel&3] >> 16);
  44
  45         gp2x_memregs[0x2910>>1] = msw;
  46         gp2x_memregs[0x2914>>1] = msw;
  47         gp2x_memregs[0x290E>>1] = lsw;
  48         gp2x_memregs[0x2912>>1] = lsw;
  49
  50         // jump to other buffer:
  51         g_screen_ptr = gp2x_screens[++screensel&3];
  52 }
  53
  54 /* doulblebuffered flip */
  55 void gp2x_video_flip2(void)
  56 {
  57         unsigned short msw = (unsigned short)(gp2x_screenaddrs_use[screensel&1] >> 16);
  58
  59         gp2x_memregs[0x2910>>1] = msw;
  60         gp2x_memregs[0x2914>>1] = msw;
  61         gp2x_memregs[0x290E>>1] = 0;
  62         gp2x_memregs[0x2912>>1] = 0;
  63
  64         // jump to other buffer:
  65         g_screen_ptr = gp2x_screens[++screensel&1];
  66 }
  67
  68 void gp2x_video_changemode_ll(int bpp)
  69 {
  70         gp2x_memregs[0x28DA>>1] = (((bpp+1)/8)<<9)|0xAB; /*8/15/16/24bpp...*/
  71         gp2x_memregs[0x290C>>1] = 320*((bpp+1)/8); /*line width in bytes*/
  72 }
  73
  74 void gp2x_video_setpalette(int *pal, int len)
  75 {
  76         unsigned short *g = (unsigned short *)pal;
  77         volatile unsigned short *memreg = &gp2x_memregs[0x295A>>1];
  78
  79         gp2x_memregs[0x2958>>1] = 0;
  80
  81         len *= 2;
  82         while (len--)
  83                 *memreg = *g++;
  84 }
  85
  86 // TV Compatible function //
  87 void gp2x_video_RGB_setscaling(int ln_offs, int W, int H)
  88 {
  89         float escalaw, escalah;
  90         int bpp = (gp2x_memregs[0x28DA>>1]>>9)&0x3;
  91         unsigned short scalw;
  92
  93         // set offset
  94         gp2x_screenaddrs_use[0] = gp2x_screenaddrs[0] + ln_offs * 320 * bpp;
  95         gp2x_screenaddrs_use[1] = gp2x_screenaddrs[1] + ln_offs * 320 * bpp;
  96         gp2x_screenaddrs_use[2] = gp2x_screenaddrs[2] + ln_offs * 320 * bpp;
  97         gp2x_screenaddrs_use[3] = gp2x_screenaddrs[3] + ln_offs * 320 * bpp;
  98
  99         escalaw = 1024.0; // RGB Horiz LCD
 100         escalah = 320.0; // RGB Vert LCD
 101
 102         if(gp2x_memregs[0x2800>>1]&0x100) //TV-Out
 103         {
 104                 escalaw=489.0; // RGB Horiz TV (PAL, NTSC)
 105                 if (gp2x_memregs[0x2818>>1]  == 287) //PAL
 106                         escalah=274.0; // RGB Vert TV PAL
 107                 else if (gp2x_memregs[0x2818>>1]  == 239) //NTSC
 108                         escalah=331.0; // RGB Vert TV NTSC
 109         }
 110
 111         // scale horizontal
 112         scalw = (unsigned short)((float)escalaw *(W/320.0));
 113         /* if there is no horizontal scaling, vertical doesn't work. Here is a nasty wrokaround... */
 114         if (H != 240 && W == 320) scalw--;
 115         gp2x_memregs[0x2906>>1]=scalw;
 116         // scale vertical
 117         gp2x_memregl[0x2908>>2]=(unsigned long)((float)escalah *bpp *(H/240.0));
 118 }
 119
 120 void gp2x_video_wait_vsync(void)
 121 {
 122         unsigned short v = gp2x_memregs[0x1182>>1];
 123         while (!((v ^ gp2x_memregs[0x1182>>1]) & 0x10))
 124                 spend_cycles(1024);
 125 }
 126
 127 /* 940 */
 128 void pause940(int yes)
 129 {
 130         if (yes)
 131                 gp2x_memregs[0x0904>>1] &= 0xFFFE;
 132         else
 133                 gp2x_memregs[0x0904>>1] |= 1;
 134 }
 135
 136 void reset940(int yes, int bank)
 137 {
 138         gp2x_memregs[0x3B48>>1] = ((yes&1) << 7) | (bank & 0x03);
 139 }
 140
 141 /*
 142  * CPU clock
 143  * Fout = (m * Fin) / (p * 2^s)
 144  * m = MDIV+8, p = PDIV+2, s = SDIV
 145  *
 146  * m = (Fout * p * 2^s) / Fin
 147  */
 148
 149 #define SYS_CLK_FREQ 7372800
 150
 151 void gp2x_set_cpuclk(unsigned int mhz)
 152 {
 153         unsigned int mdiv, pdiv, sdiv = 0;
 154         unsigned int v;
 155         int i;
 156
 157         pdiv = 3;
 158         mdiv = (mhz * pdiv * 1000000) / SYS_CLK_FREQ;
 159         if (mdiv & ~0xff) {
 160                 fprintf(stderr, "invalid cpuclk MHz: %u\n", mhz);
 161                 return;
 162         }
 163         v = ((mdiv-8)<<8) | ((pdiv-2)<<2) | sdiv;
 164         gp2x_memregs[0x910>>1] = v;
 165
 166         for (i = 0; i < 10000; i++)
 167                 if (!(gp2x_memregs[0x902>>1] & 1))
 168                         break;
 169 }
 170
 171 /* RAM timings */
 172 static unsigned short memtimex[2];
 173
 174 #define TIMING_CHECK(t, adj, mask) \
 175         t += adj; \
 176         if (t & ~mask) \
 177                 goto bad
 178
 179 void set_ram_timings(int tCAS, int tRC, int tRAS, int tWR, int tMRD, int tRFC, int tRP, int tRCD)
 180 {
 181         int i;
 182         TIMING_CHECK(tCAS, -2, 0x1);
 183         TIMING_CHECK(tRC,  -1, 0xf);
 184         TIMING_CHECK(tRAS, -1, 0xf);
 185         TIMING_CHECK(tWR,  -1, 0xf);
 186         TIMING_CHECK(tMRD, -1, 0xf);
 187         TIMING_CHECK(tRFC, -1, 0xf);
 188         TIMING_CHECK(tRP,  -1, 0xf);
 189         TIMING_CHECK(tRCD, -1, 0xf);
 190
 191         /* get spend_cycles() into cache */
 192         spend_cycles(1);
 193
 194         gp2x_memregs[0x3802>>1] = ((tMRD & 0xF) << 12) | ((tRFC & 0xF) << 8) | ((tRP & 0xF) << 4) | (tRCD & 0xF);
 195         gp2x_memregs[0x3804>>1] = 0x8000 | ((tCAS & 1) << 12) | ((tRC & 0xF) << 8) | ((tRAS & 0xF) << 4) | (tWR & 0xF);
 196
 197         /* be sure we don't access the mem while it's being reprogrammed */
 198         spend_cycles(128*1024);
 199         for (i = 0; i < 8*1024; i++)
 200                 if (!(gp2x_memregs[0x3804>>1] & 0x8000))
 201                         break;
 202
 203         printf("RAM timings set.\n");
 204         return;
 205 bad:
 206         fprintf(stderr, "RAM timings invalid.\n");
 207 }
 208
 209 void unset_ram_timings(void)
 210 {
 211         gp2x_memregs[0x3802>>1] = memtimex[0];
 212         gp2x_memregs[0x3804>>1] = memtimex[1] | 0x8000;
 213         printf("RAM timings reset to startup values.\n");
 214 }
 215
 216 /* LCD refresh */
 217 typedef struct
 218 {
 219         unsigned short reg, valmask, val;
 220 }
 221 reg_setting;
 222
 223 /* 120.00 97/0/2/7|25/ 7/ 7/11/37 */
 224 static const reg_setting lcd_rate_120[] =
 225 {
 226         { 0x0914, 0xffff, (97<<8)|(0<<2)|2 },   /* UPLLSETVREG */
 227         { 0x0924, 0xff00, (2<<14)|(7<<8) },     /* DISPCSETREG */
 228         { 0x281A, 0x00ff, 25 },                 /* .HSWID(T2) */
 229         { 0x281C, 0x00ff, 7 },                  /* .HSSTR(T8) */
 230         { 0x281E, 0x00ff, 7 },                  /* .HSEND(T7) */
 231         { 0x2822, 0x01ff, 11 },                 /* .VSEND (T9) */
 232         { 0x2826, 0x0ff0, 37<<4 },              /* .DESTR(T3) */
 233         { 0, 0, 0 }
 234 };
 235
 236 /* 100.00 96/0/2/7|29/25/53/15/37 */
 237 static const reg_setting lcd_rate_100[] =
 238 {
 239         { 0x0914, 0xffff, (96<<8)|(0<<2)|2 },   /* UPLLSETVREG */
 240         { 0x0924, 0xff00, (2<<14)|(7<<8) },     /* DISPCSETREG */
 241         { 0x281A, 0x00ff, 29 },                 /* .HSWID(T2) */
 242         { 0x281C, 0x00ff, 25 },                 /* .HSSTR(T8) */
 243         { 0x281E, 0x00ff, 53 },                 /* .HSEND(T7) */
 244         { 0x2822, 0x01ff, 15 },                 /* .VSEND (T9) */
 245         { 0x2826, 0x0ff0, 37<<4 },              /* .DESTR(T3) */
 246         { 0, 0, 0 }
 247 };
 248
 249 static reg_setting lcd_rate_defaults[] =
 250 {
 251         { 0x0914, 0xffff, 0 },
 252         { 0x0924, 0xff00, 0 },
 253         { 0x281A, 0x00ff, 0 },
 254         { 0x281C, 0x00ff, 0 },
 255         { 0x281E, 0x00ff, 0 },
 256         { 0x2822, 0x01ff, 0 },
 257         { 0x2826, 0x0ff0, 0 },
 258         { 0, 0, 0 }
 259 };
 260
 261 static void get_reg_setting(reg_setting *set)
 262 {
 263         for (; set->reg; set++)
 264         {
 265                 unsigned short val = gp2x_memregs[set->reg >> 1];
 266                 val &= set->valmask;
 267                 set->val = val;
 268         }
 269 }
 270
 271 static void set_reg_setting(const reg_setting *set)
 272 {
 273         for (; set->reg; set++)
 274         {
 275                 unsigned short val = gp2x_memregs[set->reg >> 1];
 276                 val &= ~set->valmask;
 277                 val |= set->val;
 278                 gp2x_memregs[set->reg >> 1] = val;
 279         }
 280 }
 281
 282 void set_lcd_custom_rate(int is_pal)
 283 {
 284         if (gp2x_memregs[0x2800>>1] & 0x100) // tv-out
 285                 return;
 286
 287         printf("setting custom LCD refresh (%d Hz)... ", is_pal ? 100 : 120);
 288         fflush(stdout);
 289
 290         set_reg_setting(is_pal ? lcd_rate_100 : lcd_rate_120);
 291         printf("done.\n");
 292 }
 293
 294 void unset_lcd_custom_rate(void)
 295 {
 296         printf("reset to prev LCD refresh.\n");
 297         set_reg_setting(lcd_rate_defaults);
 298 }
 299
 300 void set_lcd_gamma(int g100, int A_SNs_curve)
 301 {
 302         float gamma = (float) g100 / 100;
 303         int i;
 304         gamma = 1 / gamma;
 305
 306         /* enable gamma */
 307         gp2x_memregs[0x2880>>1] &= ~(1<<12);
 308
 309         gp2x_memregs[0x295C>>1] = 0;
 310         for (i = 0; i < 256; i++)
 311         {
 312                 unsigned char g;
 313                 unsigned short s;
 314                 const unsigned short grey50=143, grey75=177, grey25=97;
 315                 double blah;
 316
 317                 if (A_SNs_curve)
 318                 {
 319                         // The next formula is all about gaussian interpolation
 320                         blah = ((  -128 * exp(-powf((float) i/64.0f + 2.0f , 2.0f))) +
 321                                 (   -64 * exp(-powf((float) i/64.0f + 1.0f , 2.0f))) +
 322                                 (grey25 * exp(-powf((float) i/64.0f - 1.0f , 2.0f))) +
 323                                 (grey50 * exp(-powf((float) i/64.0f - 2.0f , 2.0f))) +
 324                                 (grey75 * exp(-powf((float) i/64.0f - 3.0f , 2.0f))) +
 325                                 (   256 * exp(-powf((float) i/64.0f - 4.0f , 2.0f))) +
 326                                 (   320 * exp(-powf((float) i/64.0f - 5.0f , 2.0f))) +
 327                                 (   384 * exp(-powf((float) i/64.0f - 6.0f , 2.0f)))) / 1.772637;
 328                         blah += 0.5;
 329                 }
 330                 else
 331                 {
 332                         blah = i;
 333                 }
 334
 335                 g = (unsigned char)(255.0 * pow(blah/255.0, gamma));
 336                 //printf("%d : %d\n", i, g);
 337                 s = (g<<8) | g;
 338                 gp2x_memregs[0x295E>>1]= s;
 339                 gp2x_memregs[0x295E>>1]= g;
 340         }
 341 }
 342
 343
 344 /* these are not quite MMSP2 related,
 345  * more to GP2X F100/F200 consoles themselves. */
 346 typedef struct ucb1x00_ts_event
 347 {
 348         unsigned short pressure;
 349         unsigned short x;
 350         unsigned short y;
 351         unsigned short pad;
 352         struct timeval stamp;
 353 } UCB1X00_TS_EVENT;
 354
 355 int gp2x_touchpad_read(int *x, int *y)
 356 {
 357         UCB1X00_TS_EVENT event;
 358         static int zero_seen = 0;
 359         int retval;
 360
 361         if (touchdev < 0) return -1;
 362
 363         retval = read(touchdev, &event, sizeof(event));
 364         if (retval <= 0) {
 365                 perror("touch read failed");
 366                 return -1;
 367         }
 368         // this is to ignore the messed-up 4.1.x driver
 369         if (event.pressure == 0) zero_seen = 1;
 370
 371         if (x) *x = (event.x * touchcal[0] + touchcal[2]) >> 16;
 372         if (y) *y = (event.y * touchcal[4] + touchcal[5]) >> 16;
 373         // printf("read %i %i %i\n", event.pressure, *x, *y);
 374
 375         return zero_seen ? event.pressure : 0;
 376 }
 377
 378 static void proc_set(const char *path, const char *val)
 379 {
 380         FILE *f;
 381         char tmp[16];
 382
 383         f = fopen(path, "w");
 384         if (f == NULL) {
 385                 printf("failed to open: %s\n", path);
 386                 return;
 387         }
 388
 389         fprintf(f, "0\n");
 390         fclose(f);
 391
 392         printf("\"%s\" is set to: ", path);
 393         f = fopen(path, "r");
 394         if (f == NULL) {
 395                 printf("(open failed)\n");
 396                 return;
 397         }
 398
 399         fgets(tmp, sizeof(tmp), f);
 400         printf("%s", tmp);
 401         fclose(f);
 402 }
 403
 404
 405 void mmsp2_init(void)
 406 {
 407         int i;
 408
 409         memdev = open("/dev/mem", O_RDWR);
 410         if (memdev == -1)
 411         {
 412                 perror("open(\"/dev/mem\")");
 413                 exit(1);
 414         }
 415
 416         gp2x_memregs = mmap(0, 0x10000, PROT_READ|PROT_WRITE, MAP_SHARED, memdev, 0xc0000000);
 417         if (gp2x_memregs == MAP_FAILED)
 418         {
 419                 perror("mmap(memregs)");
 420                 exit(1);
 421         }
 422         gp2x_memregl = (unsigned long *) gp2x_memregs;
 423
 424         gp2x_memregs[0x2880>>1] &= ~0x383; // disable cursor, subpict, osd, video layers
 425
 426         gp2x_screens[0] = mmap(0, FRAMEBUFF_WHOLESIZE, PROT_WRITE, MAP_SHARED,
 427                 memdev, gp2x_screenaddrs[0]);
 428         if (gp2x_screens[0] == MAP_FAILED)
 429         {
 430                 perror("mmap(g_screen_ptr)");
 431                 exit(1);
 432         }
 433         printf("framebuffers:\n");
 434         printf("  %08x -> %p\n", gp2x_screenaddrs[0], gp2x_screens[0]);
 435         for (i = 1; i < 4; i++)
 436         {
 437                 gp2x_screens[i] = (char *) gp2x_screens[i - 1] + FRAMEBUFF_SIZE;
 438                 printf("  %08x -> %p\n", gp2x_screenaddrs[i], gp2x_screens[i]);
 439         }
 440
 441         g_screen_ptr = gp2x_screens[0];
 442         screensel = 0;
 443
 444         gp2x_screenaddr_old[0] = gp2x_memregs[0x290E>>1];
 445         gp2x_screenaddr_old[1] = gp2x_memregs[0x2910>>1];
 446         gp2x_screenaddr_old[2] = gp2x_memregs[0x2912>>1];
 447         gp2x_screenaddr_old[3] = gp2x_memregs[0x2914>>1];
 448
 449         memcpy(gp2x_screenaddrs_use, gp2x_screenaddrs, sizeof(gp2x_screenaddrs));
 450
 451         /* default LCD refresh */
 452         get_reg_setting(lcd_rate_defaults);
 453
 454         /* RAM timings */
 455         memtimex[0] = gp2x_memregs[0x3802>>1];
 456         memtimex[1] = gp2x_memregs[0x3804>>1];
 457
 458         /* touchscreen */
 459         touchdev = open("/dev/touchscreen/wm97xx", O_RDONLY);
 460         if (touchdev >= 0) {
 461                 FILE *pcf = fopen("/etc/pointercal", "r");
 462                 if (pcf) {
 463                         fscanf(pcf, "%d %d %d %d %d %d %d", &touchcal[0], &touchcal[1],
 464                                 &touchcal[2], &touchcal[3], &touchcal[4], &touchcal[5], &touchcal[6]);
 465                         fclose(pcf);
 466                 }
 467                 printf("found touchscreen/wm97xx\n");
 468         }
 469
 470         /* disable Linux read-ahead */
 471         proc_set("/proc/sys/vm/max-readahead", "0\n");
 472         proc_set("/proc/sys/vm/min-readahead", "0\n");
 473
 474         /* code940 portion */
 475         sharedmem940_init();
 476 }
 477
 478 void mmsp2_finish(void)
 479 {
 480         reset940(1, 3);
 481         pause940(1);
 482         sharedmem940_finish();
 483
 484         gp2x_memregs[0x290E>>1] = gp2x_screenaddr_old[0];
 485         gp2x_memregs[0x2910>>1] = gp2x_screenaddr_old[1];
 486         gp2x_memregs[0x2912>>1] = gp2x_screenaddr_old[2];
 487         gp2x_memregs[0x2914>>1] = gp2x_screenaddr_old[3];
 488
 489         unset_ram_timings();
 490         unset_lcd_custom_rate();
 491
 492         munmap(gp2x_screens[0], FRAMEBUFF_WHOLESIZE);
 493         munmap((void *)gp2x_memregs, 0x10000);
 494         close(memdev);
 495         if (touchdev >= 0)
 496                 close(touchdev);
 497 }
 498