firmware/scroll_engine.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 by Michael Sevakis
  11  *
  12  * LCD scrolling driver and scheduler
  13  *
  14  * Much collected and combined from the various Rockbox LCD drivers.
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version 2
  19  * of the License, or (at your option) any later version.
  20  *
  21  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  22  * KIND, either express or implied.
  23  *
  24  ****************************************************************************/
  25 #include "config.h"
  26 #include "cpu.h"
  27 #include "kernel.h"
  28 #include "thread.h"
  29 #include "usb.h"
  30 #include "lcd.h"
  31 #include "font.h"
  32 #ifdef HAVE_REMOTE_LCD
  33 #include "lcd-remote.h"
  34 #endif
  35 #include "scroll_engine.h"
  36
  37 static const char scroll_tick_table[16] = {
  38  /* Hz values:
  39     1, 1.25, 1.55, 2, 2.5, 3.12, 4, 5, 6.25, 8.33, 10, 12.5, 16.7, 20, 25, 33 */
  40     100, 80, 64, 50, 40, 32, 25, 20, 16, 12, 10, 8, 6, 5, 4, 3
  41 };
  42
  43 static void scroll_thread(void);
  44 static char scroll_stack[DEFAULT_STACK_SIZE*3];
  45 static const char scroll_name[] = "scroll";
  46
  47 static struct scrollinfo lcd_scroll[LCD_SCROLLABLE_LINES];
  48
  49 #ifdef HAVE_REMOTE_LCD
  50 struct scrollinfo lcd_remote_scroll[LCD_REMOTE_SCROLLABLE_LINES];
  51 struct event_queue scroll_queue;
  52 #endif
  53
  54 struct scroll_screen_info lcd_scroll_info =
  55 {
  56     .scroll       = lcd_scroll,
  57     .lines        = 0,
  58     .ticks        = 12,
  59     .delay        = HZ/2,
  60     .bidir_limit  = 50,
  61 #ifdef HAVE_LCD_BITMAP
  62     .step         = 6,
  63 #endif
  64 #ifdef HAVE_LCD_CHARCELLS
  65     .jump_scroll_delay = HZ/4,
  66     .jump_scroll       = 0,
  67 #endif
  68 };
  69
  70 #ifdef HAVE_REMOTE_LCD
  71 struct scroll_screen_info lcd_remote_scroll_info =
  72 {
  73     .scroll       = lcd_remote_scroll,
  74     .lines        = 0,
  75     .ticks        = 12,
  76     .delay        = HZ/2,
  77     .bidir_limit  = 50,
  78     .step         = 6,
  79 };
  80 #endif /* HAVE_REMOTE_LCD */
  81
  82 void lcd_stop_scroll(void)
  83 {
  84     lcd_scroll_info.lines = 0;
  85 }
  86
  87 /* Stop scrolling line y in the specified viewport, or all lines if y < 0 */
  88 void lcd_scroll_stop_line(const struct viewport* current_vp, int y)
  89 {
  90     int i = 0;
  91
  92     while (i < lcd_scroll_info.lines)
  93     {
  94         if ((lcd_scroll_info.scroll[i].vp == current_vp) &&
  95             ((y < 0) || (lcd_scroll_info.scroll[i].y == y)))
  96         {
  97             /* If i is not the last active line in the array, then move
  98                the last item to position i */
  99             if ((i + 1) != lcd_scroll_info.lines)
 100             {
 101                 lcd_scroll_info.scroll[i] =
 102                     lcd_scroll_info.scroll[lcd_scroll_info.lines-1];
 103             }
 104             lcd_scroll_info.lines--;
 105
 106             /* A line can only appear once, so we're done,
 107              * unless we are clearing the whole viewport */
 108             if (y >= 0)
 109                 return ;
 110         }
 111         else
 112         {
 113             i++;
 114         }
 115     }
 116 }
 117
 118 /* Stop all scrolling lines in the specified viewport */
 119 void lcd_scroll_stop(const struct viewport* vp)
 120 {
 121     lcd_scroll_stop_line(vp, -1);
 122 }
 123
 124 void lcd_scroll_speed(int speed)
 125 {
 126     lcd_scroll_info.ticks = scroll_tick_table[speed];
 127 }
 128
 129 #if defined(HAVE_LCD_BITMAP)
 130 void lcd_scroll_step(int step)
 131 {
 132     lcd_scroll_info.step = step;
 133 }
 134 #endif
 135
 136 void lcd_scroll_delay(int ms)
 137 {
 138     lcd_scroll_info.delay = ms / (HZ / 10);
 139 }
 140
 141 void lcd_bidir_scroll(int percent)
 142 {
 143     lcd_scroll_info.bidir_limit = percent;
 144 }
 145
 146 #ifdef HAVE_LCD_CHARCELLS
 147 void lcd_jump_scroll(int mode) /* 0=off, 1=once, ..., JUMP_SCROLL_ALWAYS */
 148 {
 149     lcd_scroll_info.jump_scroll = mode;
 150 }
 151
 152 void lcd_jump_scroll_delay(int ms)
 153 {
 154     lcd_scroll_info.jump_scroll_delay = ms / (HZ / 10);
 155 }
 156 #endif
 157
 158 #ifdef HAVE_REMOTE_LCD
 159 void lcd_remote_stop_scroll(void)
 160 {
 161     lcd_remote_scroll_info.lines = 0;
 162 }
 163
 164 /* Stop scrolling line y in the specified viewport, or all lines if y < 0 */
 165 void lcd_remote_scroll_stop_line(const struct viewport* current_vp, int y)
 166 {
 167     int i = 0;
 168
 169     while (i < lcd_remote_scroll_info.lines)
 170     {
 171         if ((lcd_remote_scroll_info.scroll[i].vp == current_vp) &&
 172             ((y < 0) || (lcd_remote_scroll_info.scroll[i].y == y)))
 173         {
 174             /* If i is not the last active line in the array, then move
 175                the last item to position i */
 176             if ((i + 1) != lcd_remote_scroll_info.lines)
 177             {
 178                 lcd_remote_scroll_info.scroll[i] =
 179                     lcd_remote_scroll_info.scroll[lcd_remote_scroll_info.lines-1];
 180             }
 181             lcd_remote_scroll_info.lines--;
 182
 183             /* A line can only appear once, so we're done,
 184              * unless we are clearing the whole viewport */
 185             if (y >= 0)
 186                 return ;
 187         }
 188         else
 189         {
 190             i++;
 191         }
 192     }
 193 }
 194
 195 /* Stop all scrolling lines in the specified viewport */
 196 void lcd_remote_scroll_stop(const struct viewport* vp)
 197 {
 198     lcd_remote_scroll_stop_line(vp, -1);
 199 }
 200
 201 void lcd_remote_scroll_speed(int speed)
 202 {
 203     lcd_remote_scroll_info.ticks = scroll_tick_table[speed];
 204 }
 205
 206 void lcd_remote_scroll_step(int step)
 207 {
 208     lcd_remote_scroll_info.step = step;
 209 }
 210
 211 void lcd_remote_scroll_delay(int ms)
 212 {
 213     lcd_remote_scroll_info.delay = ms / (HZ / 10);
 214 }
 215
 216 void lcd_remote_bidir_scroll(int percent)
 217 {
 218     lcd_remote_scroll_info.bidir_limit = percent;
 219 }
 220
 221 static void sync_display_ticks(void)
 222 {
 223     lcd_scroll_info.last_scroll =
 224     lcd_remote_scroll_info.last_scroll = current_tick;
 225 }
 226
 227 static bool scroll_process_message(int delay)
 228 {
 229     struct queue_event ev;
 230
 231     do
 232     {
 233         long tick = current_tick;
 234         queue_wait_w_tmo(&scroll_queue, &ev, delay);
 235
 236         switch (ev.id)
 237         {
 238         case SYS_TIMEOUT:
 239             return false;
 240         case SYS_USB_CONNECTED:
 241             usb_acknowledge(SYS_USB_CONNECTED_ACK);
 242             usb_wait_for_disconnect(&scroll_queue);
 243             sync_display_ticks();
 244             return true;
 245 #ifndef SIMULATOR
 246         case SYS_REMOTE_PLUGGED:
 247             if (!remote_initialized)
 248                 sync_display_ticks();
 249 #endif
 250         }
 251
 252         delay -= current_tick - tick;
 253     }
 254     while (delay > 0);
 255
 256     return false;
 257 }
 258 #endif /* HAVE_REMOTE_LCD */
 259
 260 static void scroll_thread(void) __attribute__((noreturn));
 261 #ifdef HAVE_REMOTE_LCD
 262
 263 static void scroll_thread(void)
 264 {
 265     enum
 266     {
 267         SCROLL_LCD        = 0x1,
 268         SCROLL_LCD_REMOTE = 0x2,
 269     };
 270
 271     sync_display_ticks();
 272
 273     while ( 1 )
 274     {
 275         long delay;
 276         int scroll;
 277         long tick_lcd, tick_remote;
 278
 279         tick_lcd = lcd_scroll_info.last_scroll + lcd_scroll_info.ticks;
 280         delay = current_tick;
 281
 282         if (
 283 #ifndef SIMULATOR
 284             !remote_initialized ||
 285 #endif
 286             (tick_remote = lcd_remote_scroll_info.last_scroll +
 287                            lcd_remote_scroll_info.ticks,
 288              TIME_BEFORE(tick_lcd, tick_remote)))
 289         {
 290             scroll = SCROLL_LCD;
 291             delay = tick_lcd - delay;
 292         }
 293         /* TIME_BEFORE(tick_remote, tick_lcd) */
 294         else if (tick_lcd != tick_remote)
 295         {
 296             scroll = SCROLL_LCD_REMOTE;
 297             delay = tick_remote - delay;
 298         }
 299         else
 300         {
 301             scroll = SCROLL_LCD | SCROLL_LCD_REMOTE;
 302             delay = tick_lcd - delay;
 303         }
 304
 305         if (scroll_process_message(delay))
 306             continue;
 307
 308         if (scroll & SCROLL_LCD)
 309         {
 310 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 311             if (lcd_active())
 312 #endif
 313                 lcd_scroll_fn();
 314             lcd_scroll_info.last_scroll = current_tick;
 315         }
 316
 317         if (scroll == (SCROLL_LCD | SCROLL_LCD_REMOTE))
 318             yield();
 319
 320         if (scroll & SCROLL_LCD_REMOTE)
 321         {
 322             lcd_remote_scroll_fn();
 323             lcd_remote_scroll_info.last_scroll = current_tick;
 324         }
 325     }
 326 }
 327 #else
 328 static void scroll_thread(void)
 329 {
 330     while (1)
 331     {
 332         sleep(lcd_scroll_info.ticks);
 333 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
 334         if (lcd_active())
 335 #endif
 336             lcd_scroll_fn();
 337     }
 338 }
 339 #endif /* HAVE_REMOTE_LCD */
 340
 341 void scroll_init(void)
 342 {
 343 #ifdef HAVE_REMOTE_LCD
 344     queue_init(&scroll_queue, true);
 345 #endif
 346     create_thread(scroll_thread, scroll_stack,
 347                   sizeof(scroll_stack), 0, scroll_name
 348                   IF_PRIO(, PRIORITY_USER_INTERFACE)
 349                   IF_COP(, CPU));
 350 }
 351