gp2x/soc_mmsp2.c

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