arch/sandbox/cpu/sdl.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013 Google, Inc
   4  */
   5
   6 #include <errno.h>
   7 #include <unistd.h>
   8 #include <stdbool.h>
   9 #include <linux/input.h>
  10 #include <SDL2/SDL.h>
  11 #include <asm/state.h>
  12
  13 /**
  14  * struct buf_info - a data buffer holding audio data
  15  *
  16  * @pos:        Current position playing in audio buffer
  17  * @size:       Size of data in audio buffer (0=empty)
  18  * @alloced:    Allocated size of audio buffer (max size it can hold)
  19  * @data:       Audio data
  20  */
  21 struct buf_info {
  22         uint pos;
  23         uint size;
  24         uint alloced;
  25         uint8_t *data;
  26 };
  27
  28 /**
  29  * struct sdl_info - Information about our use of the SDL library
  30  *
  31  * @width: Width of simulated LCD display
  32  * @height: Height of simulated LCD display
  33  * @vis_width: Visible width (may be larger to allow for scaling up)
  34  * @vis_height: Visible height (may be larger to allow for scaling up)
  35  * @depth: Depth of the display in bits per pixel (16 or 32)
  36  * @pitch: Number of bytes per line of the display
  37  * @sample_rate: Current sample rate for audio
  38  * @audio_active: true if audio can be used
  39  * @inited: true if this module is initialised
  40  * @cur_buf: Current audio buffer being used by sandbox_sdl_fill_audio (0 or 1)
  41  * @buf: The two available audio buffers. SDL can be reading from one while we
  42  *      are setting up the next
  43  * @running: true if audio is running
  44  * @stopping: true if audio will stop once it runs out of data
  45  * @texture: SDL texture to use for U-Boot display contents
  46  * @renderer: SDL renderer to use
  47  * @src_depth: Number of bits per pixel in the source frame buffer (that we read
  48  * from and render to SDL)
  49  */
  50 static struct sdl_info {
  51         int width;
  52         int height;
  53         int vis_width;
  54         int vis_height;
  55         int depth;
  56         int pitch;
  57         uint sample_rate;
  58         bool audio_active;
  59         bool inited;
  60         int cur_buf;
  61         struct buf_info buf[2];
  62         bool running;
  63         bool stopping;
  64         SDL_Texture *texture;
  65         SDL_Renderer *renderer;
  66         int src_depth;
  67 } sdl;
  68
  69 static void sandbox_sdl_poll_events(void)
  70 {
  71         /*
  72          * We don't want to include common.h in this file since it uses
  73          * system headers. So add a declation here.
  74          */
  75         extern void reset_cpu(void);
  76         SDL_Event event;
  77
  78         while (SDL_PollEvent(&event)) {
  79                 switch (event.type) {
  80                 case SDL_QUIT:
  81                         puts("LCD window closed - quitting\n");
  82                         reset_cpu();
  83                         break;
  84                 }
  85         }
  86 }
  87
  88 static int sandbox_sdl_ensure_init(void)
  89 {
  90         if (!sdl.inited) {
  91                 if (SDL_Init(0) < 0) {
  92                         printf("Unable to initialise SDL: %s\n",
  93                                SDL_GetError());
  94                         return -EIO;
  95                 }
  96
  97                 atexit(SDL_Quit);
  98
  99                 sdl.inited = true;
 100         }
 101         return 0;
 102 }
 103
 104 int sandbox_sdl_init_display(int width, int height, int log2_bpp,
 105                              bool double_size)
 106 {
 107         struct sandbox_state *state = state_get_current();
 108         int err;
 109
 110         if (!width || !state->show_lcd)
 111                 return 0;
 112         err = sandbox_sdl_ensure_init();
 113         if (err)
 114                 return err;
 115         if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
 116                 printf("Unable to initialise SDL LCD: %s\n", SDL_GetError());
 117                 return -EPERM;
 118         }
 119         sdl.width = width;
 120         sdl.height = height;
 121         if (double_size) {
 122                 sdl.vis_width = sdl.width * 2;
 123                 sdl.vis_height = sdl.height * 2;
 124         } else {
 125                 sdl.vis_width = sdl.width;
 126                 sdl.vis_height = sdl.height;
 127         }
 128
 129         if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1"))
 130                 printf("Unable to init hinting: %s", SDL_GetError());
 131
 132         sdl.src_depth = 1 << log2_bpp;
 133         if (log2_bpp != 4 && log2_bpp != 5)
 134                 log2_bpp = 5;
 135         sdl.depth = 1 << log2_bpp;
 136         sdl.pitch = sdl.width * sdl.depth / 8;
 137         SDL_Window *screen = SDL_CreateWindow("U-Boot", SDL_WINDOWPOS_UNDEFINED,
 138                                               SDL_WINDOWPOS_UNDEFINED,
 139                                               sdl.vis_width, sdl.vis_height,
 140                                               SDL_WINDOW_RESIZABLE);
 141         if (!screen) {
 142                 printf("Unable to initialise SDL screen: %s\n",
 143                        SDL_GetError());
 144                 return -EIO;
 145         }
 146         sdl.renderer = SDL_CreateRenderer(screen, -1,
 147                                           SDL_RENDERER_ACCELERATED |
 148                                           SDL_RENDERER_PRESENTVSYNC);
 149         if (!sdl.renderer) {
 150                 printf("Unable to initialise SDL renderer: %s\n",
 151                        SDL_GetError());
 152                 return -EIO;
 153         }
 154
 155         sdl.texture = SDL_CreateTexture(sdl.renderer, log2_bpp == 4 ?
 156                                         SDL_PIXELFORMAT_RGB565 :
 157                                         SDL_PIXELFORMAT_RGB888,
 158                                         SDL_TEXTUREACCESS_STREAMING,
 159                                         width, height);
 160         if (!sdl.texture) {
 161                 printf("Unable to initialise SDL texture: %s\n",
 162                        SDL_GetError());
 163                 return -EBADF;
 164         }
 165         sandbox_sdl_poll_events();
 166
 167         return 0;
 168 }
 169
 170 static int copy_to_texture(void *lcd_base)
 171 {
 172         char *dest;
 173         int pitch, x, y;
 174         int src_pitch;
 175         void *pixels;
 176         char *src;
 177         int ret;
 178
 179         if (sdl.src_depth == sdl.depth) {
 180                 SDL_UpdateTexture(sdl.texture, NULL, lcd_base, sdl.pitch);
 181                 return 0;
 182         }
 183
 184         /*
 185          * We only support copying from an 8bpp to a 32bpp texture since the
 186          * other cases are supported directly by the texture.
 187          */
 188         if (sdl.depth != 32 && sdl.src_depth != 8) {
 189                 printf("Need depth 32bpp for copy\n");
 190                 return -EINVAL;
 191         }
 192
 193         ret = SDL_LockTexture(sdl.texture, NULL, &pixels, &pitch);
 194         if (ret) {
 195                 printf("SDL lock %d: %s\n", ret, SDL_GetError());
 196                 return ret;
 197         }
 198
 199         /* Copy the pixels one by one */
 200         src_pitch = sdl.width * sdl.src_depth / 8;
 201         for (y = 0; y < sdl.height; y++) {
 202                 char val;
 203
 204                 dest = pixels + y * pitch;
 205                 src = lcd_base + src_pitch * y;
 206                 for (x = 0; x < sdl.width; x++, dest += 4) {
 207                         val = *src++;
 208                         dest[0] = val;
 209                         dest[1] = val;
 210                         dest[2] = val;
 211                         dest[3] = 0;
 212                 }
 213         }
 214         SDL_UnlockTexture(sdl.texture);
 215
 216         return 0;
 217 }
 218
 219 int sandbox_sdl_sync(void *lcd_base)
 220 {
 221         struct SDL_Rect rect;
 222         int ret;
 223
 224         if (!sdl.texture)
 225                 return 0;
 226         SDL_RenderClear(sdl.renderer);
 227         ret = copy_to_texture(lcd_base);
 228         if (ret) {
 229                 printf("copy_to_texture: %d: %s\n", ret, SDL_GetError());
 230                 return -EIO;
 231         }
 232         ret = SDL_RenderCopy(sdl.renderer, sdl.texture, NULL, NULL);
 233         if (ret) {
 234                 printf("SDL copy %d: %s\n", ret, SDL_GetError());
 235                 return -EIO;
 236         }
 237
 238         /*
 239          * On some machines this does not appear. Draw an empty rectangle which
 240          * seems to fix that.
 241          */
 242         rect.x = 0;
 243         rect.y = 0;
 244         rect.w = 0;
 245         rect.h = 0;
 246         SDL_RenderDrawRect(sdl.renderer, &rect);
 247
 248         SDL_RenderPresent(sdl.renderer);
 249         sandbox_sdl_poll_events();
 250
 251         return 0;
 252 }
 253
 254 static const unsigned short sdl_to_keycode[SDL_NUM_SCANCODES] = {
 255         [SDL_SCANCODE_ESCAPE]   = KEY_ESC,
 256         [SDL_SCANCODE_1]        = KEY_1,
 257         [SDL_SCANCODE_2]        = KEY_2,
 258         [SDL_SCANCODE_3]        = KEY_3,
 259         [SDL_SCANCODE_4]        = KEY_4,
 260         [SDL_SCANCODE_5]        = KEY_5,
 261         [SDL_SCANCODE_6]        = KEY_6,
 262         [SDL_SCANCODE_7]        = KEY_7,
 263         [SDL_SCANCODE_8]        = KEY_8,
 264         [SDL_SCANCODE_9]        = KEY_9,
 265         [SDL_SCANCODE_0]        = KEY_0,
 266         [SDL_SCANCODE_MINUS]    = KEY_MINUS,
 267         [SDL_SCANCODE_EQUALS]   = KEY_EQUAL,
 268         [SDL_SCANCODE_BACKSPACE]        = KEY_BACKSPACE,
 269         [SDL_SCANCODE_TAB]      = KEY_TAB,
 270         [SDL_SCANCODE_Q]        = KEY_Q,
 271         [SDL_SCANCODE_W]        = KEY_W,
 272         [SDL_SCANCODE_E]        = KEY_E,
 273         [SDL_SCANCODE_R]        = KEY_R,
 274         [SDL_SCANCODE_T]        = KEY_T,
 275         [SDL_SCANCODE_Y]        = KEY_Y,
 276         [SDL_SCANCODE_U]        = KEY_U,
 277         [SDL_SCANCODE_I]        = KEY_I,
 278         [SDL_SCANCODE_O]        = KEY_O,
 279         [SDL_SCANCODE_P]        = KEY_P,
 280         [SDL_SCANCODE_LEFTBRACKET]      = KEY_LEFTBRACE,
 281         [SDL_SCANCODE_RIGHTBRACKET]     = KEY_RIGHTBRACE,
 282         [SDL_SCANCODE_RETURN]   = KEY_ENTER,
 283         [SDL_SCANCODE_LCTRL]    = KEY_LEFTCTRL,
 284         [SDL_SCANCODE_A]        = KEY_A,
 285         [SDL_SCANCODE_S]        = KEY_S,
 286         [SDL_SCANCODE_D]        = KEY_D,
 287         [SDL_SCANCODE_F]        = KEY_F,
 288         [SDL_SCANCODE_G]        = KEY_G,
 289         [SDL_SCANCODE_H]        = KEY_H,
 290         [SDL_SCANCODE_J]        = KEY_J,
 291         [SDL_SCANCODE_K]        = KEY_K,
 292         [SDL_SCANCODE_L]        = KEY_L,
 293         [SDL_SCANCODE_SEMICOLON]        = KEY_SEMICOLON,
 294         [SDL_SCANCODE_APOSTROPHE]       = KEY_APOSTROPHE,
 295         [SDL_SCANCODE_GRAVE]    = KEY_GRAVE,
 296         [SDL_SCANCODE_LSHIFT]   = KEY_LEFTSHIFT,
 297         [SDL_SCANCODE_BACKSLASH]        = KEY_BACKSLASH,
 298         [SDL_SCANCODE_Z]        = KEY_Z,
 299         [SDL_SCANCODE_X]        = KEY_X,
 300         [SDL_SCANCODE_C]        = KEY_C,
 301         [SDL_SCANCODE_V]        = KEY_V,
 302         [SDL_SCANCODE_B]        = KEY_B,
 303         [SDL_SCANCODE_N]        = KEY_N,
 304         [SDL_SCANCODE_M]        = KEY_M,
 305         [SDL_SCANCODE_COMMA]    = KEY_COMMA,
 306         [SDL_SCANCODE_PERIOD]   = KEY_DOT,
 307         [SDL_SCANCODE_SLASH]    = KEY_SLASH,
 308         [SDL_SCANCODE_RSHIFT]   = KEY_RIGHTSHIFT,
 309         [SDL_SCANCODE_KP_MULTIPLY] = KEY_KPASTERISK,
 310         [SDL_SCANCODE_LALT]     = KEY_LEFTALT,
 311         [SDL_SCANCODE_SPACE]    = KEY_SPACE,
 312         [SDL_SCANCODE_CAPSLOCK] = KEY_CAPSLOCK,
 313         [SDL_SCANCODE_F1]       = KEY_F1,
 314         [SDL_SCANCODE_F2]       = KEY_F2,
 315         [SDL_SCANCODE_F3]       = KEY_F3,
 316         [SDL_SCANCODE_F4]       = KEY_F4,
 317         [SDL_SCANCODE_F5]       = KEY_F5,
 318         [SDL_SCANCODE_F6]       = KEY_F6,
 319         [SDL_SCANCODE_F7]       = KEY_F7,
 320         [SDL_SCANCODE_F8]       = KEY_F8,
 321         [SDL_SCANCODE_F9]       = KEY_F9,
 322         [SDL_SCANCODE_F10]      = KEY_F10,
 323         [SDL_SCANCODE_NUMLOCKCLEAR]     = KEY_NUMLOCK,
 324         [SDL_SCANCODE_SCROLLLOCK]       = KEY_SCROLLLOCK,
 325         [SDL_SCANCODE_KP_7]     = KEY_KP7,
 326         [SDL_SCANCODE_KP_8]     = KEY_KP8,
 327         [SDL_SCANCODE_KP_9]     = KEY_KP9,
 328         [SDL_SCANCODE_KP_MINUS] = KEY_KPMINUS,
 329         [SDL_SCANCODE_KP_4]     = KEY_KP4,
 330         [SDL_SCANCODE_KP_5]     = KEY_KP5,
 331         [SDL_SCANCODE_KP_6]     = KEY_KP6,
 332         [SDL_SCANCODE_KP_PLUS]  = KEY_KPPLUS,
 333         [SDL_SCANCODE_KP_1]     = KEY_KP1,
 334         [SDL_SCANCODE_KP_2]     = KEY_KP2,
 335         [SDL_SCANCODE_KP_3]     = KEY_KP3,
 336         [SDL_SCANCODE_KP_0]     = KEY_KP0,
 337         [SDL_SCANCODE_KP_PERIOD]        = KEY_KPDOT,
 338         /* key 84 does not exist linux_input.h */
 339         [SDL_SCANCODE_LANG5]    =  KEY_ZENKAKUHANKAKU,
 340         [SDL_SCANCODE_NONUSBACKSLASH]   = KEY_102ND,
 341         [SDL_SCANCODE_F11]      = KEY_F11,
 342         [SDL_SCANCODE_F12]      = KEY_F12,
 343         [SDL_SCANCODE_INTERNATIONAL1]   = KEY_RO,
 344         [SDL_SCANCODE_LANG3]    = KEY_KATAKANA,
 345         [SDL_SCANCODE_LANG4]    = KEY_HIRAGANA,
 346         [SDL_SCANCODE_INTERNATIONAL4] = KEY_HENKAN,
 347         [SDL_SCANCODE_INTERNATIONAL2] = KEY_KATAKANAHIRAGANA,
 348         [SDL_SCANCODE_INTERNATIONAL5] = KEY_MUHENKAN,
 349         /* [SDL_SCANCODE_INTERNATIONAL5] -> [KEY_KPJPCOMMA] */
 350         [SDL_SCANCODE_KP_ENTER] = KEY_KPENTER,
 351         [SDL_SCANCODE_RCTRL]    = KEY_RIGHTCTRL,
 352         [SDL_SCANCODE_KP_DIVIDE] = KEY_KPSLASH,
 353         [SDL_SCANCODE_SYSREQ]   = KEY_SYSRQ,
 354         [SDL_SCANCODE_RALT]     = KEY_RIGHTALT,
 355         /* KEY_LINEFEED */
 356         [SDL_SCANCODE_HOME]     = KEY_HOME,
 357         [SDL_SCANCODE_UP]       = KEY_UP,
 358         [SDL_SCANCODE_PAGEUP]   = KEY_PAGEUP,
 359         [SDL_SCANCODE_LEFT]     = KEY_LEFT,
 360         [SDL_SCANCODE_RIGHT]    = KEY_RIGHT,
 361         [SDL_SCANCODE_END]      = KEY_END,
 362         [SDL_SCANCODE_DOWN]     = KEY_DOWN,
 363         [SDL_SCANCODE_PAGEDOWN] = KEY_PAGEDOWN,
 364         [SDL_SCANCODE_INSERT]   = KEY_INSERT,
 365         [SDL_SCANCODE_DELETE]   = KEY_DELETE,
 366         /* KEY_MACRO */
 367         [SDL_SCANCODE_MUTE]     = KEY_MUTE,
 368         [SDL_SCANCODE_VOLUMEDOWN]       = KEY_VOLUMEDOWN,
 369         [SDL_SCANCODE_VOLUMEUP] = KEY_VOLUMEUP,
 370         [SDL_SCANCODE_POWER]    = KEY_POWER,
 371         [SDL_SCANCODE_KP_EQUALS]        = KEY_KPEQUAL,
 372         [SDL_SCANCODE_KP_PLUSMINUS]     = KEY_KPPLUSMINUS,
 373         [SDL_SCANCODE_PAUSE]    = KEY_PAUSE,
 374         /* KEY_SCALE */
 375         [SDL_SCANCODE_KP_COMMA] = KEY_KPCOMMA,
 376         [SDL_SCANCODE_LANG1]    = KEY_HANGUEL,
 377         [SDL_SCANCODE_LANG2]    = KEY_HANJA,
 378         [SDL_SCANCODE_INTERNATIONAL3]   = KEY_YEN,
 379         [SDL_SCANCODE_LGUI]     = KEY_LEFTMETA,
 380         [SDL_SCANCODE_RGUI]     = KEY_RIGHTMETA,
 381         [SDL_SCANCODE_APPLICATION] = KEY_COMPOSE,
 382 };
 383
 384 int sandbox_sdl_scan_keys(int key[], int max_keys)
 385 {
 386         const Uint8 *keystate;
 387         int num_keys;
 388         int i, count;
 389
 390         sandbox_sdl_poll_events();
 391         keystate = SDL_GetKeyboardState(&num_keys);
 392         for (i = count = 0; i < num_keys; i++) {
 393                 if (count < max_keys && keystate[i]) {
 394                         int keycode = sdl_to_keycode[i];
 395
 396                         if (keycode)
 397                                 key[count++] = keycode;
 398                 }
 399         }
 400
 401         return count;
 402 }
 403
 404 int sandbox_sdl_key_pressed(int keycode)
 405 {
 406         int key[8];     /* allow up to 8 keys to be pressed at once */
 407         int count;
 408         int i;
 409
 410         count = sandbox_sdl_scan_keys(key, sizeof(key) / sizeof(key[0]));
 411         for (i = 0; i < count; i++) {
 412                 if (key[i] == keycode)
 413                         return 0;
 414         }
 415
 416         return -ENOENT;
 417 }
 418
 419 void sandbox_sdl_fill_audio(void *udata, Uint8 *stream, int len)
 420 {
 421         struct buf_info *buf;
 422         int avail;
 423         bool have_data = false;
 424         int i;
 425
 426         for (i = 0; i < 2; i++) {
 427                 buf = &sdl.buf[sdl.cur_buf];
 428                 avail = buf->size - buf->pos;
 429                 if (avail <= 0) {
 430                         sdl.cur_buf = 1 - sdl.cur_buf;
 431                         continue;
 432                 }
 433                 if (avail > len)
 434                         avail = len;
 435                 have_data = true;
 436
 437                 SDL_MixAudio(stream, buf->data + buf->pos, avail,
 438                              SDL_MIX_MAXVOLUME);
 439                 buf->pos += avail;
 440                 len -= avail;
 441
 442                 /* Move to next buffer if we are at the end */
 443                 if (buf->pos == buf->size)
 444                         buf->size = 0;
 445                 else
 446                         break;
 447         }
 448         sdl.stopping = !have_data;
 449 }
 450
 451 int sandbox_sdl_sound_init(int rate, int channels)
 452 {
 453         SDL_AudioSpec wanted, have;
 454         int i;
 455
 456         if (sandbox_sdl_ensure_init())
 457                 return -1;
 458
 459         if (sdl.audio_active)
 460                 return 0;
 461
 462         /* Set the audio format */
 463         wanted.freq = rate;
 464         wanted.format = AUDIO_S16;
 465         wanted.channels = channels;
 466         wanted.samples = 1024;  /* Good low-latency value for callback */
 467         wanted.callback = sandbox_sdl_fill_audio;
 468         wanted.userdata = NULL;
 469
 470         for (i = 0; i < 2; i++) {
 471                 struct buf_info *buf = &sdl.buf[i];
 472
 473                 buf->alloced = sizeof(uint16_t) * wanted.freq * wanted.channels;
 474                 buf->data = malloc(buf->alloced);
 475                 if (!buf->data) {
 476                         printf("%s: Out of memory\n", __func__);
 477                         if (i == 1)
 478                                 free(sdl.buf[0].data);
 479                         return -1;
 480                 }
 481                 buf->pos = 0;
 482                 buf->size = 0;
 483         }
 484
 485         if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
 486                 printf("Unable to initialise SDL audio: %s\n", SDL_GetError());
 487                 goto err;
 488         }
 489
 490         /* Open the audio device, forcing the desired format */
 491         if (SDL_OpenAudio(&wanted, &have) < 0) {
 492                 printf("Couldn't open audio: %s\n", SDL_GetError());
 493                 goto err;
 494         }
 495         if (have.format != wanted.format) {
 496                 printf("Couldn't select required audio format\n");
 497                 goto err;
 498         }
 499         sdl.audio_active = true;
 500         sdl.sample_rate = wanted.freq;
 501         sdl.cur_buf = 0;
 502         sdl.running = false;
 503
 504         return 0;
 505
 506 err:
 507         for (i = 0; i < 2; i++)
 508                 free(sdl.buf[i].data);
 509         return -1;
 510 }
 511
 512 int sandbox_sdl_sound_play(const void *data, uint size)
 513 {
 514         struct buf_info *buf;
 515
 516         if (!sdl.audio_active)
 517                 return 0;
 518
 519         buf = &sdl.buf[0];
 520         if (buf->size)
 521                 buf = &sdl.buf[1];
 522         while (buf->size)
 523                 usleep(1000);
 524
 525         if (size > buf->alloced)
 526                 return -E2BIG;
 527
 528         memcpy(buf->data, data, size);
 529         buf->size = size;
 530         buf->pos = 0;
 531         if (!sdl.running) {
 532                 SDL_PauseAudio(0);
 533                 sdl.running = true;
 534                 sdl.stopping = false;
 535         }
 536
 537         return 0;
 538 }
 539
 540 int sandbox_sdl_sound_stop(void)
 541 {
 542         if (sdl.running) {
 543                 while (!sdl.stopping)
 544                         SDL_Delay(100);
 545
 546                 SDL_PauseAudio(1);
 547                 sdl.running = 0;
 548                 sdl.stopping = false;
 549         }
 550
 551         return 0;
 552 }