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  */
  48 static struct sdl_info {
  49         int width;
  50         int height;
  51         int vis_width;
  52         int vis_height;
  53         int depth;
  54         int pitch;
  55         uint sample_rate;
  56         bool audio_active;
  57         bool inited;
  58         int cur_buf;
  59         struct buf_info buf[2];
  60         bool running;
  61         bool stopping;
  62         SDL_Texture *texture;
  63         SDL_Renderer *renderer;
  64 } sdl;
  65
  66 static void sandbox_sdl_poll_events(void)
  67 {
  68         /*
  69          * We don't want to include common.h in this file since it uses
  70          * system headers. So add a declation here.
  71          */
  72         extern void reset_cpu(unsigned long addr);
  73         SDL_Event event;
  74
  75         while (SDL_PollEvent(&event)) {
  76                 switch (event.type) {
  77                 case SDL_QUIT:
  78                         puts("LCD window closed - quitting\n");
  79                         reset_cpu(1);
  80                         break;
  81                 }
  82         }
  83 }
  84
  85 static int sandbox_sdl_ensure_init(void)
  86 {
  87         if (!sdl.inited) {
  88                 if (SDL_Init(0) < 0) {
  89                         printf("Unable to initialise SDL: %s\n",
  90                                SDL_GetError());
  91                         return -EIO;
  92                 }
  93
  94                 atexit(SDL_Quit);
  95
  96                 sdl.inited = true;
  97         }
  98         return 0;
  99 }
 100
 101 int sandbox_sdl_init_display(int width, int height, int log2_bpp,
 102                              bool double_size)
 103 {
 104         struct sandbox_state *state = state_get_current();
 105         int err;
 106
 107         if (!width || !state->show_lcd)
 108                 return 0;
 109         err = sandbox_sdl_ensure_init();
 110         if (err)
 111                 return err;
 112         if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
 113                 printf("Unable to initialise SDL LCD: %s\n", SDL_GetError());
 114                 return -EPERM;
 115         }
 116         sdl.width = width;
 117         sdl.height = height;
 118         if (double_size) {
 119                 sdl.vis_width = sdl.width * 2;
 120                 sdl.vis_height = sdl.height * 2;
 121         } else {
 122                 sdl.vis_width = sdl.width;
 123                 sdl.vis_height = sdl.height;
 124         }
 125
 126         sdl.depth = 1 << log2_bpp;
 127         sdl.pitch = sdl.width * sdl.depth / 8;
 128         SDL_Window *screen = SDL_CreateWindow("U-Boot", SDL_WINDOWPOS_UNDEFINED,
 129                                               SDL_WINDOWPOS_UNDEFINED,
 130                                               sdl.vis_width, sdl.vis_height, 0);
 131         if (!screen) {
 132                 printf("Unable to initialise SDL screen: %s\n",
 133                        SDL_GetError());
 134                 return -EIO;
 135         }
 136         if (log2_bpp != 4 && log2_bpp != 5) {
 137                 printf("U-Boot SDL does not support depth %d\n", log2_bpp);
 138                 return -EINVAL;
 139         }
 140         sdl.renderer = SDL_CreateRenderer(screen, -1,
 141                                           SDL_RENDERER_ACCELERATED |
 142                                           SDL_RENDERER_PRESENTVSYNC);
 143         if (!sdl.renderer) {
 144                 printf("Unable to initialise SDL renderer: %s\n",
 145                        SDL_GetError());
 146                 return -EIO;
 147         }
 148
 149         sdl.texture = SDL_CreateTexture(sdl.renderer, log2_bpp == 4 ?
 150                                         SDL_PIXELFORMAT_RGB565 :
 151                                         SDL_PIXELFORMAT_RGB888,
 152                                         SDL_TEXTUREACCESS_STREAMING,
 153                                         width, height);
 154         if (!sdl.texture) {
 155                 printf("Unable to initialise SDL texture: %s\n",
 156                        SDL_GetError());
 157                 return -EBADF;
 158         }
 159         sandbox_sdl_poll_events();
 160
 161         return 0;
 162 }
 163
 164 int sandbox_sdl_sync(void *lcd_base)
 165 {
 166         SDL_UpdateTexture(sdl.texture, NULL, lcd_base, sdl.pitch);
 167         SDL_RenderCopy(sdl.renderer, sdl.texture, NULL, NULL);
 168         SDL_RenderPresent(sdl.renderer);
 169         sandbox_sdl_poll_events();
 170
 171         return 0;
 172 }
 173
 174 static const unsigned short sdl_to_keycode[SDL_NUM_SCANCODES] = {
 175         [SDL_SCANCODE_A]        = KEY_A,
 176         [SDL_SCANCODE_B]        = KEY_B,
 177         [SDL_SCANCODE_C]        = KEY_C,
 178         [SDL_SCANCODE_D]        = KEY_D,
 179         [SDL_SCANCODE_E]        = KEY_E,
 180         [SDL_SCANCODE_F]        = KEY_F,
 181         [SDL_SCANCODE_G]        = KEY_G,
 182         [SDL_SCANCODE_H]        = KEY_H,
 183         [SDL_SCANCODE_I]        = KEY_I,
 184         [SDL_SCANCODE_J]        = KEY_J,
 185         [SDL_SCANCODE_K]        = KEY_K,
 186         [SDL_SCANCODE_L]        = KEY_L,
 187         [SDL_SCANCODE_M]        = KEY_M,
 188         [SDL_SCANCODE_N]        = KEY_N,
 189         [SDL_SCANCODE_O]        = KEY_O,
 190         [SDL_SCANCODE_P]        = KEY_P,
 191         [SDL_SCANCODE_Q]        = KEY_Q,
 192         [SDL_SCANCODE_R]        = KEY_R,
 193         [SDL_SCANCODE_S]        = KEY_S,
 194         [SDL_SCANCODE_T]        = KEY_T,
 195         [SDL_SCANCODE_U]        = KEY_U,
 196         [SDL_SCANCODE_V]        = KEY_V,
 197         [SDL_SCANCODE_W]        = KEY_W,
 198         [SDL_SCANCODE_X]        = KEY_X,
 199         [SDL_SCANCODE_Y]        = KEY_Y,
 200         [SDL_SCANCODE_Z]        = KEY_Z,
 201
 202         [SDL_SCANCODE_1]        = KEY_1,
 203         [SDL_SCANCODE_2]        = KEY_2,
 204         [SDL_SCANCODE_3]        = KEY_3,
 205         [SDL_SCANCODE_4]        = KEY_4,
 206         [SDL_SCANCODE_5]        = KEY_5,
 207         [SDL_SCANCODE_6]        = KEY_6,
 208         [SDL_SCANCODE_7]        = KEY_7,
 209         [SDL_SCANCODE_8]        = KEY_8,
 210         [SDL_SCANCODE_9]        = KEY_9,
 211         [SDL_SCANCODE_0]        = KEY_0,
 212
 213         [SDL_SCANCODE_RETURN]   = KEY_ENTER,
 214         [SDL_SCANCODE_ESCAPE]   = KEY_ESC,
 215         [SDL_SCANCODE_BACKSPACE]        = KEY_BACKSPACE,
 216         [SDL_SCANCODE_TAB]      = KEY_TAB,
 217         [SDL_SCANCODE_SPACE]    = KEY_SPACE,
 218
 219         [SDL_SCANCODE_MINUS]    = KEY_MINUS,
 220         [SDL_SCANCODE_EQUALS]   = KEY_EQUAL,
 221         [SDL_SCANCODE_BACKSLASH]        = KEY_BACKSLASH,
 222         [SDL_SCANCODE_SEMICOLON]        = KEY_SEMICOLON,
 223         [SDL_SCANCODE_APOSTROPHE]       = KEY_APOSTROPHE,
 224         [SDL_SCANCODE_GRAVE]    = KEY_GRAVE,
 225         [SDL_SCANCODE_COMMA]    = KEY_COMMA,
 226         [SDL_SCANCODE_PERIOD]   = KEY_DOT,
 227         [SDL_SCANCODE_SLASH]    = KEY_SLASH,
 228
 229         [SDL_SCANCODE_CAPSLOCK] = KEY_CAPSLOCK,
 230
 231         [SDL_SCANCODE_F1]       = KEY_F1,
 232         [SDL_SCANCODE_F2]       = KEY_F2,
 233         [SDL_SCANCODE_F3]       = KEY_F3,
 234         [SDL_SCANCODE_F4]       = KEY_F4,
 235         [SDL_SCANCODE_F5]       = KEY_F5,
 236         [SDL_SCANCODE_F6]       = KEY_F6,
 237         [SDL_SCANCODE_F7]       = KEY_F7,
 238         [SDL_SCANCODE_F8]       = KEY_F8,
 239         [SDL_SCANCODE_F9]       = KEY_F9,
 240         [SDL_SCANCODE_F10]      = KEY_F10,
 241         [SDL_SCANCODE_F11]      = KEY_F11,
 242         [SDL_SCANCODE_F12]      = KEY_F12,
 243
 244         [SDL_SCANCODE_PRINTSCREEN]      = KEY_PRINT,
 245         [SDL_SCANCODE_SCROLLLOCK]       = KEY_SCROLLLOCK,
 246         [SDL_SCANCODE_PAUSE]    = KEY_PAUSE,
 247         [SDL_SCANCODE_INSERT]   = KEY_INSERT,
 248         [SDL_SCANCODE_HOME]     = KEY_HOME,
 249         [SDL_SCANCODE_PAGEUP]   = KEY_PAGEUP,
 250         [SDL_SCANCODE_DELETE]   = KEY_DELETE,
 251         [SDL_SCANCODE_END]      = KEY_END,
 252         [SDL_SCANCODE_PAGEDOWN] = KEY_PAGEDOWN,
 253         [SDL_SCANCODE_RIGHT]    = KEY_RIGHT,
 254         [SDL_SCANCODE_LEFT]     = KEY_LEFT,
 255         [SDL_SCANCODE_DOWN]     = KEY_DOWN,
 256         [SDL_SCANCODE_UP]       = KEY_UP,
 257
 258         [SDL_SCANCODE_NUMLOCKCLEAR]     = KEY_NUMLOCK,
 259         [SDL_SCANCODE_KP_DIVIDE]        = KEY_KPSLASH,
 260         [SDL_SCANCODE_KP_MULTIPLY]      = KEY_KPASTERISK,
 261         [SDL_SCANCODE_KP_MINUS] = KEY_KPMINUS,
 262         [SDL_SCANCODE_KP_PLUS]  = KEY_KPPLUS,
 263         [SDL_SCANCODE_KP_ENTER] = KEY_KPENTER,
 264         [SDL_SCANCODE_KP_1]     = KEY_KP1,
 265         [SDL_SCANCODE_KP_2]     = KEY_KP2,
 266         [SDL_SCANCODE_KP_3]     = KEY_KP3,
 267         [SDL_SCANCODE_KP_4]     = KEY_KP4,
 268         [SDL_SCANCODE_KP_5]     = KEY_KP5,
 269         [SDL_SCANCODE_KP_6]     = KEY_KP6,
 270         [SDL_SCANCODE_KP_7]     = KEY_KP7,
 271         [SDL_SCANCODE_KP_8]     = KEY_KP8,
 272         [SDL_SCANCODE_KP_9]     = KEY_KP9,
 273         [SDL_SCANCODE_KP_0]     = KEY_KP0,
 274         [SDL_SCANCODE_KP_PERIOD]        = KEY_KPDOT,
 275
 276         [SDL_SCANCODE_KP_EQUALS]        = KEY_KPEQUAL,
 277         [SDL_SCANCODE_KP_COMMA] = KEY_KPCOMMA,
 278
 279         [SDL_SCANCODE_SYSREQ]   = KEY_SYSRQ,
 280 };
 281
 282 int sandbox_sdl_scan_keys(int key[], int max_keys)
 283 {
 284         const Uint8 *keystate;
 285         int num_keys;
 286         int i, count;
 287
 288         sandbox_sdl_poll_events();
 289         keystate = SDL_GetKeyboardState(&num_keys);
 290         for (i = count = 0; i < num_keys; i++) {
 291                 if (count < max_keys && keystate[i]) {
 292                         int keycode = sdl_to_keycode[i];
 293
 294                         if (keycode)
 295                                 key[count++] = keycode;
 296                 }
 297         }
 298
 299         return count;
 300 }
 301
 302 int sandbox_sdl_key_pressed(int keycode)
 303 {
 304         int key[8];     /* allow up to 8 keys to be pressed at once */
 305         int count;
 306         int i;
 307
 308         count = sandbox_sdl_scan_keys(key, sizeof(key) / sizeof(key[0]));
 309         for (i = 0; i < count; i++) {
 310                 if (key[i] == keycode)
 311                         return 0;
 312         }
 313
 314         return -ENOENT;
 315 }
 316
 317 void sandbox_sdl_fill_audio(void *udata, Uint8 *stream, int len)
 318 {
 319         struct buf_info *buf;
 320         int avail;
 321         bool have_data = false;
 322         int i;
 323
 324         for (i = 0; i < 2; i++) {
 325                 buf = &sdl.buf[sdl.cur_buf];
 326                 avail = buf->size - buf->pos;
 327                 if (avail <= 0) {
 328                         sdl.cur_buf = 1 - sdl.cur_buf;
 329                         continue;
 330                 }
 331                 if (avail > len)
 332                         avail = len;
 333                 have_data = true;
 334
 335                 SDL_MixAudio(stream, buf->data + buf->pos, avail,
 336                              SDL_MIX_MAXVOLUME);
 337                 buf->pos += avail;
 338                 len -= avail;
 339
 340                 /* Move to next buffer if we are at the end */
 341                 if (buf->pos == buf->size)
 342                         buf->size = 0;
 343                 else
 344                         break;
 345         }
 346         sdl.stopping = !have_data;
 347 }
 348
 349 int sandbox_sdl_sound_init(int rate, int channels)
 350 {
 351         SDL_AudioSpec wanted, have;
 352         int i;
 353
 354         if (sandbox_sdl_ensure_init())
 355                 return -1;
 356
 357         if (sdl.audio_active)
 358                 return 0;
 359
 360         /* Set the audio format */
 361         wanted.freq = rate;
 362         wanted.format = AUDIO_S16;
 363         wanted.channels = channels;
 364         wanted.samples = 1024;  /* Good low-latency value for callback */
 365         wanted.callback = sandbox_sdl_fill_audio;
 366         wanted.userdata = NULL;
 367
 368         for (i = 0; i < 2; i++) {
 369                 struct buf_info *buf = &sdl.buf[i];
 370
 371                 buf->alloced = sizeof(uint16_t) * wanted.freq * wanted.channels;
 372                 buf->data = malloc(buf->alloced);
 373                 if (!buf->data) {
 374                         printf("%s: Out of memory\n", __func__);
 375                         if (i == 1)
 376                                 free(sdl.buf[0].data);
 377                         return -1;
 378                 }
 379                 buf->pos = 0;
 380                 buf->size = 0;
 381         }
 382
 383         if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
 384                 printf("Unable to initialise SDL audio: %s\n", SDL_GetError());
 385                 goto err;
 386         }
 387
 388         /* Open the audio device, forcing the desired format */
 389         if (SDL_OpenAudio(&wanted, &have) < 0) {
 390                 printf("Couldn't open audio: %s\n", SDL_GetError());
 391                 goto err;
 392         }
 393         if (have.format != wanted.format) {
 394                 printf("Couldn't select required audio format\n");
 395                 goto err;
 396         }
 397         sdl.audio_active = true;
 398         sdl.sample_rate = wanted.freq;
 399         sdl.cur_buf = 0;
 400         sdl.running = false;
 401
 402         return 0;
 403
 404 err:
 405         for (i = 0; i < 2; i++)
 406                 free(sdl.buf[i].data);
 407         return -1;
 408 }
 409
 410 int sandbox_sdl_sound_play(const void *data, uint size)
 411 {
 412         struct buf_info *buf;
 413
 414         if (!sdl.audio_active)
 415                 return 0;
 416
 417         buf = &sdl.buf[0];
 418         if (buf->size)
 419                 buf = &sdl.buf[1];
 420         while (buf->size)
 421                 usleep(1000);
 422
 423         if (size > buf->alloced)
 424                 return -E2BIG;
 425
 426         memcpy(buf->data, data, size);
 427         buf->size = size;
 428         buf->pos = 0;
 429         if (!sdl.running) {
 430                 SDL_PauseAudio(0);
 431                 sdl.running = true;
 432                 sdl.stopping = false;
 433         }
 434
 435         return 0;
 436 }
 437
 438 int sandbox_sdl_sound_stop(void)
 439 {
 440         if (sdl.running) {
 441                 while (!sdl.stopping)
 442                         SDL_Delay(100);
 443
 444                 SDL_PauseAudio(1);
 445                 sdl.running = 0;
 446                 sdl.stopping = false;
 447         }
 448
 449         return 0;
 450 }