gp2x/gp2x.c

   1 /*
   2     Parts used from cpuctrl, Copyright (C) 2005  Hermes/PS2Reality
   3     Portions Copyright (C) 2009 notaz
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19 */
  20
  21
  22 #define _GNU_SOURCE 1
  23 #include "../common.h"
  24 #include <sys/mman.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/soundcard.h>
  27 #include <sys/types.h>
  28 #include <unistd.h>
  29 #include <ctype.h>
  30 #include <linux/input.h>
  31 #include "gp2x.h"
  32 #include "pollux_dpc_set.h"
  33
  34 static u32 gpsp_gp2x_dev_audio;
  35 static u32 gpsp_gp2x_dev;
  36 #ifdef POLLUX_BUILD
  37 static u32 gpsp_gp2x_indev;
  38 static u32 saved_405c, saved_4060, saved_4058;
  39 #endif
  40
  41 static u32 gp2x_audio_volume = 74/2;
  42
  43 static volatile u16 *gpsp_gp2x_memregs;
  44 static volatile u32 *gpsp_gp2x_memregl;
  45
  46 u32 button_plat_mask_to_config[PLAT_BUTTON_COUNT] =
  47 {
  48   GP2X_UP,
  49   GP2X_LEFT,
  50   GP2X_DOWN,
  51   GP2X_RIGHT,
  52   GP2X_START,
  53   GP2X_SELECT,
  54   GP2X_L,
  55   GP2X_R,
  56   GP2X_A,
  57   GP2X_B,
  58   GP2X_X,
  59   GP2X_Y,
  60 #if defined(POLLUX_BUILD) && !defined(WIZ_BUILD)
  61   0,
  62   0,
  63   GP2X_PUSH,
  64   GP2X_HOME,
  65 #else
  66   GP2X_VOL_DOWN,
  67   GP2X_VOL_UP,
  68   GP2X_PUSH,
  69   GP2X_VOL_MIDDLE
  70 #endif
  71 };
  72
  73 u32 gamepad_config_map[PLAT_BUTTON_COUNT] =
  74 {
  75   BUTTON_ID_UP,                 // Up
  76   BUTTON_ID_LEFT,               // Left
  77   BUTTON_ID_DOWN,               // Down
  78   BUTTON_ID_RIGHT,              // Right
  79   BUTTON_ID_START,              // Start
  80   BUTTON_ID_SELECT,             // Select
  81   BUTTON_ID_L,                  // Ltrigger
  82   BUTTON_ID_R,                  // Rtrigger
  83   BUTTON_ID_FPS,                // A
  84   BUTTON_ID_A,                  // B
  85   BUTTON_ID_B,                  // X
  86   BUTTON_ID_MENU,               // Y
  87   BUTTON_ID_VOLDOWN,            // Vol down
  88   BUTTON_ID_VOLUP,              // Vol up
  89   BUTTON_ID_FPS,                // Push
  90   BUTTON_ID_MENU                // Vol middle / Home
  91 };
  92
  93 #ifdef POLLUX_BUILD
  94 #include <linux/fb.h>
  95 void *gpsp_gp2x_screen;
  96 #define fb_buf_count 4
  97 static u32 fb_paddr[fb_buf_count];
  98 static void *fb_vaddr[fb_buf_count];
  99 static u32 fb_work_buf;
 100 static int fb_buf_use;
 101 static int fbdev;
 102
 103 static void fb_video_init()
 104 {
 105   struct fb_fix_screeninfo fbfix;
 106   unsigned int r;
 107   int i, ret;
 108
 109   fbdev = open("/dev/fb0", O_RDWR);
 110   if (fbdev < 0) {
 111     perror("can't open fbdev");
 112     exit(1);
 113   }
 114
 115   ret = ioctl(fbdev, FBIOGET_FSCREENINFO, &fbfix);
 116   if (ret == -1)
 117   {
 118     perror("ioctl(fbdev) failed");
 119     exit(1);
 120   }
 121
 122   printf("framebuffer: \"%s\" @ %08lx\n", fbfix.id, fbfix.smem_start);
 123   fb_paddr[0] = fbfix.smem_start;
 124
 125   fb_vaddr[0] = mmap(0, 320*240*2*fb_buf_count, PROT_READ|PROT_WRITE,
 126     MAP_SHARED, gpsp_gp2x_dev, fb_paddr[0]);
 127   if (fb_vaddr[0] == MAP_FAILED)
 128   {
 129     perror("mmap(fb_vaddr) failed");
 130     exit(1);
 131   }
 132   memset(fb_vaddr[0], 0, 320*240*2*fb_buf_count);
 133
 134   printf("  %p -> %08x\n", fb_vaddr[0], fb_paddr[0]);
 135   for (i = 1; i < fb_buf_count; i++)
 136   {
 137     fb_paddr[i] = fb_paddr[i-1] + 320*240*2;
 138     fb_vaddr[i] = (char *)fb_vaddr[i-1] + 320*240*2;
 139     printf("  %p -> %08x\n", fb_vaddr[i], fb_paddr[i]);
 140   }
 141   fb_work_buf = 0;
 142   fb_buf_use = fb_buf_count;
 143
 144   saved_405c = gpsp_gp2x_memregl[0x405c>>2];
 145   saved_4060 = gpsp_gp2x_memregl[0x4060>>2];
 146   saved_4058 = gpsp_gp2x_memregl[0x4058>>2];
 147
 148   // set mode; program both MLCs so that TV-out works
 149   gpsp_gp2x_memregl[0x405c>>2] = gpsp_gp2x_memregl[0x445c>>2] = 2;
 150   gpsp_gp2x_memregl[0x4060>>2] = gpsp_gp2x_memregl[0x4460>>2] = 320 * 2;
 151
 152   r = gpsp_gp2x_memregl[0x4058>>2];
 153   r = (r & 0xffff) | (0x4432 << 16) | 0x10;
 154   gpsp_gp2x_memregl[0x4058>>2] = r;
 155
 156   r = gpsp_gp2x_memregl[0x4458>>2];
 157   r = (r & 0xffff) | (0x4432 << 16) | 0x10;
 158   gpsp_gp2x_memregl[0x4458>>2] = r;
 159
 160   pollux_video_flip();
 161   warm_change_cb_upper(WCB_C_BIT|WCB_B_BIT, 1);
 162 }
 163
 164 void pollux_video_flip()
 165 {
 166   gpsp_gp2x_memregl[0x406C>>2] =
 167   gpsp_gp2x_memregl[0x446C>>2] = fb_paddr[fb_work_buf];
 168   gpsp_gp2x_memregl[0x4058>>2] |= 0x10;
 169   gpsp_gp2x_memregl[0x4458>>2] |= 0x10;
 170   fb_work_buf++;
 171   if (fb_work_buf >= fb_buf_use)
 172     fb_work_buf = 0;
 173   gpsp_gp2x_screen = fb_vaddr[fb_work_buf];
 174 }
 175
 176 void fb_use_buffers(int count)
 177 {
 178   if (count < 1)
 179     count = 1;
 180   else if (count > fb_buf_count)
 181     count = fb_buf_count;
 182   fb_buf_use = count;
 183   memset(fb_vaddr[0], 0, 320*240*2*count);
 184 }
 185
 186 void wiz_lcd_set_portrait(int y)
 187 {
 188   char *dpc_settings;
 189 #ifdef WIZ_BUILD
 190   static int old_y = -1;
 191   int cmd[2] = { 0, 0 };
 192
 193   if (old_y == y)
 194     return;
 195   cmd[0] = y ? 6 : 5;
 196   ioctl(fbdev, _IOW('D', 90, int[2]), cmd);
 197   gpsp_gp2x_memregl[0x4004>>2] = y ? 0x013f00ef : 0x00ef013f;
 198   gpsp_gp2x_memregl[0x4000>>2] |= 1 << 3;
 199   old_y = y;
 200
 201   /* the above ioctl resets LCD timings, so set them here */
 202 #endif
 203
 204   dpc_settings = getenv("pollux_dpc_set");
 205   if (dpc_settings != NULL)
 206     pollux_dpc_set(gpsp_gp2x_memregs, dpc_settings);
 207 }
 208
 209 static void fb_video_exit()
 210 {
 211   /* switch to default fb mem, turn portrait off */
 212   gpsp_gp2x_memregl[0x406c>>2] = fb_paddr[0];
 213   gpsp_gp2x_memregl[0x405c>>2] = saved_405c;
 214   gpsp_gp2x_memregl[0x4060>>2] = saved_4060;
 215   gpsp_gp2x_memregl[0x4058>>2] = saved_4058 | 0x10;
 216   wiz_lcd_set_portrait(0);
 217   close(fbdev);
 218 }
 219
 220 static int wiz_gamepak_fd = -1;
 221 static u32 wiz_gamepak_size;
 222
 223 static void wiz_gamepak_cleanup()
 224 {
 225   if (wiz_gamepak_size)
 226     munmap(gamepak_rom, wiz_gamepak_size);
 227   if (wiz_gamepak_fd >= 0)
 228     close(wiz_gamepak_fd);
 229   gamepak_rom = NULL;
 230   wiz_gamepak_size = 0;
 231   wiz_gamepak_fd = -1;
 232 }
 233
 234 u32 wiz_load_gamepak(char *name)
 235 {
 236   char *dot_position = strrchr(name, '.');
 237   u32 ret;
 238
 239   if (!strcasecmp(dot_position, ".zip"))
 240   {
 241     if (wiz_gamepak_fd >= 0)
 242     {
 243       wiz_gamepak_cleanup();
 244       printf("switching to ROM malloc\n");
 245       init_gamepak_buffer();
 246     }
 247     return load_file_zip(name);
 248   }
 249
 250   if (wiz_gamepak_fd < 0)
 251   {
 252     extern void *gamepak_memory_map;
 253     free(gamepak_rom);
 254     free(gamepak_memory_map);
 255     gamepak_memory_map = NULL;
 256     printf("switching to ROM mmap\n");
 257   }
 258   else
 259     wiz_gamepak_cleanup();
 260
 261   wiz_gamepak_fd = open(name, O_RDONLY|O_NOATIME, S_IRUSR);
 262   if (wiz_gamepak_fd < 0)
 263   {
 264     perror("wiz_load_gamepak: open failed");
 265     return -1;
 266   }
 267
 268   ret = lseek(wiz_gamepak_fd, 0, SEEK_END);
 269   wiz_gamepak_size = gamepak_ram_buffer_size = ret;
 270
 271   gamepak_rom = mmap(0, ret, PROT_READ, MAP_SHARED, wiz_gamepak_fd, 0);
 272   if (gamepak_rom == MAP_FAILED)
 273   {
 274     perror("wiz_load_gamepak: mmap failed");
 275     return -1;
 276   }
 277
 278   return ret;
 279 }
 280
 281 #define KEYBITS_BIT(x) (keybits[(x)/sizeof(keybits[0])/8] & \
 282   (1 << ((x) & (sizeof(keybits[0])*8-1))))
 283
 284 static int abs_min, abs_max, lzone_step;
 285
 286 static int open_caanoo_pad(void)
 287 {
 288   long keybits[KEY_CNT / sizeof(long) / 8];
 289   long absbits[(ABS_MAX+1) / sizeof(long) / 8];
 290   struct input_absinfo ainfo;
 291   int fd = -1, i;
 292
 293   memset(keybits, 0, sizeof(keybits));
 294   memset(absbits, 0, sizeof(absbits));
 295
 296   for (i = 0;; i++)
 297   {
 298     int support = 0, need;
 299     int ret;
 300     char name[64];
 301
 302     snprintf(name, sizeof(name), "/dev/input/event%d", i);
 303     fd = open(name, O_RDONLY|O_NONBLOCK);
 304     if (fd == -1)
 305       break;
 306
 307     /* check supported events */
 308     ret = ioctl(fd, EVIOCGBIT(0, sizeof(support)), &support);
 309     if (ret == -1) {
 310       printf("in_evdev: ioctl failed on %s\n", name);
 311       goto skip;
 312     }
 313
 314     need = (1 << EV_KEY) | (1 << EV_ABS);
 315     if ((support & need) != need)
 316       goto skip;
 317
 318     ret = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
 319     if (ret == -1) {
 320       printf("in_evdev: ioctl failed on %s\n", name);
 321       goto skip;
 322     }
 323
 324     if (!KEYBITS_BIT(BTN_JOYSTICK))
 325       goto skip;
 326
 327     ret = ioctl(fd, EVIOCGABS(ABS_X), &ainfo);
 328     if (ret == -1)
 329       goto skip;
 330
 331     abs_min = ainfo.minimum;
 332     abs_max = ainfo.maximum;
 333     lzone_step = (abs_max - abs_min) / 2 / 9;
 334
 335     ioctl(fd, EVIOCGNAME(sizeof(name)), name);
 336     printf("using \"%s\" (type %08x)\n", name, support);
 337     break;
 338
 339 skip:
 340     close(fd);
 341     fd = -1;
 342   }
 343
 344   if (fd == -1) {
 345     printf("missing input device\n");
 346     exit(1);
 347   }
 348
 349   return fd;
 350 }
 351 #endif // POLLUX_BUILD
 352
 353 void gpsp_plat_init(void)
 354 {
 355   gpsp_gp2x_dev = open("/dev/mem",   O_RDWR);
 356   gpsp_gp2x_dev_audio = open("/dev/mixer", O_RDWR);
 357   gpsp_gp2x_memregl = (u32 *)mmap(0, 0x10000, PROT_READ|PROT_WRITE, MAP_SHARED,
 358    gpsp_gp2x_dev, 0xc0000000);
 359   gpsp_gp2x_memregs = (u16 *)gpsp_gp2x_memregl;
 360   warm_init();
 361 #ifdef POLLUX_BUILD
 362 #ifdef WIZ_BUILD
 363   gpsp_gp2x_indev = open("/dev/GPIO", O_RDONLY);
 364 #else
 365   gpsp_gp2x_indev = open_caanoo_pad();
 366 #endif
 367   fb_video_init();
 368   (void)open_caanoo_pad;
 369 #endif
 370
 371   gp2x_sound_volume(1);
 372 }
 373
 374 void gpsp_plat_quit(void)
 375 {
 376   chdir(main_path);
 377
 378   warm_finish();
 379 #ifdef POLLUX_BUILD
 380   wiz_gamepak_cleanup();
 381   close(gpsp_gp2x_indev);
 382   fb_video_exit();
 383 #endif
 384   munmap((void *)gpsp_gp2x_memregl, 0x10000);
 385   close(gpsp_gp2x_dev_audio);
 386   close(gpsp_gp2x_dev);
 387
 388   fcloseall();
 389   sync();
 390   exit(0);
 391 }
 392
 393 void gp2x_sound_volume(u32 volume_up)
 394 {
 395   u32 volume;
 396   if((volume_up == 0) && (gp2x_audio_volume > 0))
 397     gp2x_audio_volume--;
 398
 399   if((volume_up != 0)  && (gp2x_audio_volume < 100))
 400     gp2x_audio_volume++;
 401
 402   volume = (gp2x_audio_volume * 0x50) / 100;
 403   volume = (gp2x_audio_volume << 8) | gp2x_audio_volume;
 404   ioctl(gpsp_gp2x_dev_audio, SOUND_MIXER_WRITE_PCM, &volume);
 405 }
 406
 407 u32 gpsp_plat_joystick_read(void)
 408 {
 409 #ifdef WIZ_BUILD
 410   u32 value = 0;
 411   read(gpsp_gp2x_indev, &value, 4);
 412   if(value & 0x02)
 413    value |= 0x05;
 414   if(value & 0x08)
 415    value |= 0x14;
 416   if(value & 0x20)
 417    value |= 0x50;
 418   if(value & 0x80)
 419    value |= 0x41;
 420   return value;
 421 #elif defined(POLLUX_BUILD)
 422   // caanoo
 423   static const int evdev_to_gp2x[] = {
 424     GP2X_A, GP2X_X, GP2X_B, GP2X_Y, GP2X_L, GP2X_R,
 425     GP2X_HOME, 0, GP2X_START, GP2X_SELECT, GP2X_PUSH
 426   };
 427   int keybits[KEY_CNT / sizeof(int)];
 428   struct input_absinfo ainfo;
 429   int lzone = analog_sensitivity_level * lzone_step;
 430   u32 retval = 0;
 431   int i, ret;
 432
 433   ret = ioctl(gpsp_gp2x_indev, EVIOCGKEY(sizeof(keybits)), keybits);
 434   if (ret == -1) {
 435     perror("EVIOCGKEY ioctl failed");
 436     sleep(1);
 437     return 0;
 438   }
 439
 440   for (i = 0; i < sizeof(evdev_to_gp2x) / sizeof(evdev_to_gp2x[0]); i++) {
 441     if (KEYBITS_BIT(BTN_TRIGGER + i))
 442       retval |= evdev_to_gp2x[i];
 443   }
 444
 445   if (lzone != 0)
 446     lzone--;
 447
 448   ret = ioctl(gpsp_gp2x_indev, EVIOCGABS(ABS_X), &ainfo);
 449   if (ret != -1) {
 450     if      (ainfo.value <= abs_min + lzone) retval |= GP2X_LEFT;
 451     else if (ainfo.value >= abs_max - lzone) retval |= GP2X_RIGHT;
 452   }
 453   ret = ioctl(gpsp_gp2x_indev, EVIOCGABS(ABS_Y), &ainfo);
 454   if (ret != -1) {
 455     if      (ainfo.value <= abs_min + lzone) retval |= GP2X_UP;
 456     else if (ainfo.value >= abs_max - lzone) retval |= GP2X_DOWN;
 457   }
 458
 459   return retval;
 460 #else
 461   // GP2X
 462   u32 value = (gpsp_gp2x_memregs[0x1198 >> 1] & 0x00FF);
 463
 464   if(value == 0xFD)
 465    value = 0xFA;
 466   if(value == 0xF7)
 467    value = 0xEB;
 468   if(value == 0xDF)
 469    value = 0xAF;
 470   if(value == 0x7F)
 471    value = 0xBE;
 472
 473   return ~((gpsp_gp2x_memregs[0x1184 >> 1] & 0xFF00) | value |
 474    (gpsp_gp2x_memregs[0x1186 >> 1] << 16));
 475 #endif
 476 }
 477
 478 u32 gpsp_plat_buttons_to_cursor(u32 buttons)
 479 {
 480   gui_action_type new_button = CURSOR_NONE;
 481
 482   if(buttons & GP2X_A)
 483     new_button = CURSOR_BACK;
 484
 485   if(buttons & GP2X_X)
 486     new_button = CURSOR_EXIT;
 487
 488   if(buttons & GP2X_B)
 489     new_button = CURSOR_SELECT;
 490
 491   if(buttons & GP2X_UP)
 492     new_button = CURSOR_UP;
 493
 494   if(buttons & GP2X_DOWN)
 495     new_button = CURSOR_DOWN;
 496
 497   if(buttons & GP2X_LEFT)
 498     new_button = CURSOR_LEFT;
 499
 500   if(buttons & GP2X_RIGHT)
 501     new_button = CURSOR_RIGHT;
 502
 503   if(buttons & GP2X_L)
 504     new_button = CURSOR_L;
 505
 506   if(buttons & GP2X_R)
 507     new_button = CURSOR_R;
 508
 509   return new_button;
 510 }
 511
 512 // Fout = (m * Fin) / (p * 2^s)
 513 void set_FCLK(u32 MHZ)
 514 {
 515   u32 v;
 516   u32 mdiv, pdiv, sdiv = 0;
 517 #ifdef POLLUX_BUILD
 518   int i;
 519   #define SYS_CLK_FREQ 27
 520   // m = MDIV, p = PDIV, s = SDIV
 521   pdiv = 9;
 522   mdiv = (MHZ * pdiv) / SYS_CLK_FREQ;
 523   if (mdiv & ~0x3ff)
 524     return;
 525   v = (pdiv<<18) | (mdiv<<8) | sdiv;
 526
 527   gpsp_gp2x_memregl[0xf004>>2] = v;
 528   gpsp_gp2x_memregl[0xf07c>>2] |= 0x8000;
 529   for (i = 0; (gpsp_gp2x_memregl[0xf07c>>2] & 0x8000) && i < 0x100000; i++)
 530     ;
 531
 532   // must restart sound as it's PLL is shared with CPU one
 533   sound_exit();
 534   init_sound(0);
 535 #else
 536   #define SYS_CLK_FREQ 7372800
 537   // m = MDIV + 8, p = PDIV + 2, s = SDIV
 538   pdiv = 3;
 539   mdiv = (MHZ * pdiv * 1000000) / SYS_CLK_FREQ;
 540   mdiv &= 0xff;
 541   v = ((mdiv-8)<<8) | ((pdiv-2)<<2) | sdiv;
 542   gpsp_gp2x_memregs[0x910>>1] = v;
 543 #endif
 544 }
 545