firmware/target/arm/olympus/mrobe-100/lcd-remote-mr100.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2009 Mark Arigo
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "cpu.h"
  23 #include "kernel.h"
  24 #include "thread.h"
  25 #include "system.h"
  26 #include "lcd-remote.h"
  27 #include "lcd-remote-target.h"
  28 #include "button.h"
  29 #include "button-target.h"
  30
  31 /* Temporary defines until we sort out why the gui stuff doesn't like this size
  32    (I believe the status bar isn't doing sanity checks and is writing outside
  33    the frame buffer size). */
  34 #define RC_WIDTH                79
  35 #define RC_HEIGHT               16
  36
  37 #define RC_CONTRAST_MASK        0x000000ff
  38 #define RC_SCREEN_ON            0x00000100
  39 #define RC_BACKLIGHT_ON         0x00000200
  40
  41 #define RC_DEV_INIT             0x00001000
  42 #define RC_DETECTED             0x00002000
  43 #define RC_AWAKE                0x00004000
  44 #define RC_POWER_OFF            0x00008000
  45
  46 #define RC_UPDATE_LCD           0x00010000
  47 #define RC_UPDATE_CONTROLLER    0x00020000
  48 #define RC_UPDATE_ICONS         0x00040000
  49 #define RC_UPDATE_MASK          (RC_UPDATE_LCD|RC_UPDATE_CONTROLLER|RC_UPDATE_ICONS)
  50
  51 #define RC_TX_ERROR             0x00100000
  52 #define RC_RX_ERROR             0x00200000
  53 #define RC_TIMEOUT_ERROR        0x00400000
  54 #define RC_ERROR_MASK           (RC_TX_ERROR|RC_RX_ERROR|RC_TIMEOUT_ERROR)
  55
  56 #define RC_FORCE_DETECT         0x80000000
  57
  58 #define RX_READY                0x01
  59 #define TX_READY                0x20
  60
  61 #define POLL_TIMEOUT            50000
  62
  63 bool remote_initialized = false;
  64 unsigned int rc_status = 0;
  65 unsigned char rc_buf[5];
  66
  67 /* ================================================== */
  68 /* Remote thread functions                            */
  69 /*   These functions are private to the remote thread */
  70 /* ================================================== */
  71 static struct semaphore rc_thread_wakeup;
  72 static unsigned int remote_thread_id;
  73 static int remote_stack[256/sizeof(int)];
  74 static const char * const remote_thread_name = "remote";
  75
  76 static bool remote_wait_ready(int ready_mask)
  77 {
  78     unsigned long current;
  79     unsigned long start = USEC_TIMER;
  80     unsigned long timeout = start + POLL_TIMEOUT;
  81
  82     rc_status &= ~RC_TIMEOUT_ERROR;
  83
  84     if (start <= timeout)
  85     {
  86         do
  87         {
  88             if (SER1_LSR & ready_mask)
  89                 return true;
  90
  91             //~ sleep(1);
  92
  93             current = USEC_TIMER;
  94         } while (current < timeout);
  95     }
  96     else
  97     {
  98         do
  99         {
 100             if (SER1_LSR & ready_mask)
 101                 return true;
 102
 103             //~ sleep(1);
 104
 105             current = USEC_TIMER - POLL_TIMEOUT;
 106         } while (current < start);
 107     }
 108
 109     rc_status |= RC_TIMEOUT_ERROR;
 110     return false;
 111 }
 112
 113 static bool remote_rx(void)
 114 {
 115     int i;
 116     unsigned char chksum[2];
 117
 118     rc_status &= ~RC_RX_ERROR;
 119
 120     for (i = 0; i < 5; i++)
 121     {
 122         if (!remote_wait_ready(RX_READY))
 123         {
 124             rc_status |= RC_RX_ERROR;
 125             return false;
 126         }
 127
 128         rc_buf[i] = SER1_RBR;
 129     }
 130
 131     /* check opcode */
 132     if ((rc_buf[0] & 0xf0) != 0xf0)
 133     {
 134         rc_status |= RC_RX_ERROR;
 135         return false;
 136     }
 137
 138     /* verify the checksums */
 139     chksum[0] = chksum[1] = 0;
 140     for (i = 0; i < 3; i++)
 141     {
 142         chksum[0] ^= rc_buf[i];
 143         chksum[1] += rc_buf[i];
 144     }
 145
 146     if ((chksum[0] != rc_buf[3]) && (chksum[1] != rc_buf[4]))
 147     {
 148         rc_status |= RC_RX_ERROR;
 149         return false;
 150     }
 151
 152     /* reception error */
 153     if ((rc_buf[0] & 0x1) || (rc_buf[0] & 0x2) || (rc_buf[0] & 0x4))
 154     {
 155         rc_status |= RC_RX_ERROR;
 156         return false;
 157     }
 158
 159     return true;
 160 }
 161
 162 static bool remote_tx(unsigned char *data, int len)
 163 {
 164     int i;
 165     unsigned char chksum[2];
 166
 167     rc_status &= ~RC_TX_ERROR;
 168
 169     chksum[0] = chksum[1] = 0;
 170
 171     for (i = 0; i < len; i++)
 172     {
 173         if (!remote_wait_ready(TX_READY))
 174         {
 175             rc_status |= RC_TX_ERROR;
 176             return false;
 177         }
 178
 179         SER1_THR = data[i];
 180         chksum[0] ^= data[i];
 181         chksum[1] += data[i];
 182     }
 183
 184     for (i = 0; i < 2; i++)
 185     {
 186         if (!remote_wait_ready(TX_READY))
 187         {
 188             rc_status |= RC_TX_ERROR;
 189             return false;
 190         }
 191
 192         SER1_THR = chksum[i];
 193     }
 194
 195     return remote_rx();
 196 }
 197
 198 static void remote_dev_enable(bool enable)
 199 {
 200     if (enable)
 201     {
 202         outl(inl(0x70000018) | 0xaa000, 0x70000018);
 203         DEV_INIT2 &= ~0x800;
 204
 205         GPIO_CLEAR_BITWISE(GPIOL_OUTPUT_VAL, 0x80);
 206         GPIO_SET_BITWISE(GPIOL_OUTPUT_EN, 0x80);
 207
 208         DEV_EN |= DEV_SER1;
 209
 210         SER1_RBR;
 211         SER1_LCR = 0x80;
 212         SER1_DLL = 0x50;
 213         SER1_DLM = 0x00;
 214         SER1_LCR = 0x03;
 215         SER1_FCR = 0x07;
 216
 217         rc_status |= RC_DEV_INIT;
 218     }
 219     else
 220     {
 221         outl(inl(0x70000018) & ~0xaa000, 0x70000018);
 222         DEV_INIT2 &= ~0x800;
 223
 224         GPIO_SET_BITWISE(GPIOL_OUTPUT_VAL, 0x80);
 225         GPIO_SET_BITWISE(GPIOL_OUTPUT_EN, 0x80);
 226
 227         DEV_RS |= DEV_SER1;
 228         nop;
 229         DEV_RS &= ~DEV_SER1;
 230
 231         DEV_EN &= ~DEV_SER1;
 232
 233         rc_status &= ~RC_DEV_INIT;
 234     }
 235 }
 236
 237 static void remote_update_lcd(void)
 238 {
 239     int x, y, draw_now;
 240     unsigned char data[RC_WIDTH + 7];
 241
 242     /* If the draw_now bit is set, the draw occurs directly on the LCD.
 243        Otherwise, the data is stored in an off-screen buffer and displayed
 244        the next time a draw operation is executed with this flag set. */
 245     draw_now = 0;
 246
 247     for (y = 0; y < 2; y++)
 248     {
 249         data[0] = 0x51;
 250         data[1] = draw_now << 7;
 251         data[2] = RC_WIDTH;         /* width */
 252         data[3] = 0;                /* x1    */
 253         data[4] = y << 3;           /* y1    */
 254         data[5] = RC_WIDTH;         /* x2    */
 255         data[6] = (y + 1) << 3;     /* y2    */
 256
 257         for (x = 0; x < RC_WIDTH; x++)
 258             data[x + 7] = *FBREMOTEADDR(x,y);
 259
 260         remote_tx(data, RC_WIDTH + 7);
 261
 262         draw_now = 1;
 263     }
 264 }
 265
 266 static void remote_update_controller(void)
 267 {
 268     unsigned char data[3];
 269
 270     data[0] = 0x31;
 271     data[1] = 0x00;
 272     if (rc_status & RC_SCREEN_ON)
 273         data[1] |= 0x80;
 274     if (rc_status & RC_BACKLIGHT_ON)
 275         data[1] |= 0x40;
 276     data[2] = (unsigned char)(rc_status & RC_CONTRAST_MASK);
 277     remote_tx(data, 3);
 278 }
 279
 280 #if 0
 281 static void remote_update_icons(unsigned char symbols)
 282 {
 283     unsigned char data[2];
 284
 285     if (!(rc_status & RC_AWAKE) && !(rc_status & RC_SCREEN_ON))
 286         return;
 287
 288     data[0] = 0x41;
 289     data[1] = symbols;
 290     remote_tx(data, 2);
 291 }
 292 #endif
 293
 294 static bool remote_nop(void)
 295 {
 296     unsigned char val[2];
 297
 298     val[0] = 0x11;
 299     val[1] = 0x30;
 300     return remote_tx(val, 2);
 301 }
 302
 303 static void remote_wake(void)
 304 {
 305     if (remote_nop())
 306     {
 307         rc_status |= RC_AWAKE;
 308         return;
 309     }
 310
 311     rc_status &= ~RC_AWAKE;
 312     return;
 313 }
 314
 315 static void remote_sleep(void)
 316 {
 317     unsigned char data[2];
 318
 319     if (rc_status & RC_AWAKE)
 320     {
 321         data[0] = 0x71;
 322         data[1] = 0x30;
 323         remote_tx(data, 2);
 324
 325         udelay(25000);
 326     }
 327
 328     rc_status &= ~RC_AWAKE;
 329 }
 330
 331 static void remote_off(void)
 332 {
 333     if (rc_status & RC_AWAKE)
 334         remote_sleep();
 335
 336     if (rc_status & RC_DEV_INIT)
 337         remote_dev_enable(false);
 338
 339     rc_status &= ~(RC_DETECTED | RC_ERROR_MASK | RC_UPDATE_MASK);
 340     remote_initialized = false;
 341 }
 342
 343 static void remote_on(void)
 344 {
 345     if (!(rc_status & RC_DEV_INIT))
 346         remote_dev_enable(true);
 347
 348     remote_wake();
 349
 350     if (rc_status & RC_AWAKE)
 351     {
 352         rc_status |= RC_DETECTED;
 353         remote_initialized = true;
 354
 355         rc_status |= (RC_UPDATE_MASK | RC_SCREEN_ON | RC_BACKLIGHT_ON);
 356         //~ remote_update_icons(0xf0); /* show battery */
 357     }
 358     else
 359     {
 360         rc_status &= ~RC_DETECTED;
 361         remote_initialized = false;
 362     }
 363 }
 364
 365 static void remote_thread(void)
 366 {
 367     int rc_thread_sleep_count = 10;
 368     int rc_thread_wait_timeout = TIMEOUT_BLOCK;
 369
 370     while (1)
 371     {
 372         semaphore_wait(&rc_thread_wakeup, rc_thread_wait_timeout);
 373
 374         /* Error handling (most likely due to remote not present) */
 375         if (rc_status & RC_ERROR_MASK)
 376         {
 377             if (--rc_thread_sleep_count == 0)
 378                 rc_status |= RC_POWER_OFF;
 379         }
 380
 381         /* Power-off (thread sleeps) */
 382         if (rc_status & RC_POWER_OFF)
 383         {
 384             remote_off();
 385
 386             rc_thread_sleep_count = 10;
 387             rc_thread_wait_timeout = TIMEOUT_BLOCK;
 388
 389             continue;
 390         }
 391
 392         /* Detection */
 393         if (!(rc_status & RC_DETECTED))
 394         {
 395             rc_thread_wait_timeout = HZ;
 396
 397             if (headphones_inserted())
 398             {
 399                 remote_on();
 400
 401                 if (rc_status & RC_AWAKE)
 402                 {
 403                     rc_thread_sleep_count = 10;
 404                     rc_thread_wait_timeout = HZ/20; /* ~50ms for updates */
 405                 }
 406             }
 407             else
 408             {
 409                 if (--rc_thread_sleep_count == 0)
 410                     rc_status &= ~RC_POWER_OFF;
 411             }
 412
 413             continue;
 414         }
 415
 416         /* Update the remote (one per wakeup cycle) */
 417         if (headphones_inserted() && (rc_status & RC_AWAKE))
 418         {
 419             if (rc_status & RC_SCREEN_ON)
 420             {
 421                 /* In order of importance */
 422                 if (rc_status & RC_UPDATE_CONTROLLER)
 423                 {
 424                     remote_update_controller();
 425                     rc_status &= ~RC_UPDATE_CONTROLLER;
 426                 }
 427                 else if (rc_status & RC_UPDATE_LCD)
 428                 {
 429                     remote_update_lcd();
 430                     rc_status &= ~RC_UPDATE_LCD;
 431                 }
 432                 else
 433                 {
 434                     remote_nop();
 435                 }
 436             }
 437             else
 438             {
 439                 remote_nop();
 440             }
 441         }
 442     }
 443 }
 444
 445 /* ============================================= */
 446 /* Public functions                              */
 447 /*   These should only set the update flags that */
 448 /*   will be executed in the remote thread.      */
 449 /* ============================================= */
 450 bool lcd_remote_read_device(unsigned char *data)
 451 {
 452     if (!(rc_status & RC_AWAKE) || (rc_status & RC_ERROR_MASK))
 453         return false;
 454
 455     /* Return the most recent data. While the remote is plugged,
 456        this is updated ~50ms */
 457     data[0] = rc_buf[0];
 458     data[1] = rc_buf[1];
 459     data[2] = rc_buf[2];
 460     data[3] = rc_buf[3];
 461     data[4] = rc_buf[4];
 462
 463     return true;
 464 }
 465
 466 void lcd_remote_set_invert_display(bool yesno)
 467 {
 468     /* dummy function...need to introduce HAVE_LCD_REMOTE_INVERT */
 469     (void)yesno;
 470 }
 471
 472 /* turn the display upside down (call lcd_remote_update() afterwards) */
 473 void lcd_remote_set_flip(bool yesno)
 474 {
 475     /* dummy function...need to introduce HAVE_LCD_REMOTE_FLIP */
 476     (void)yesno;
 477 }
 478
 479 int lcd_remote_default_contrast(void)
 480 {
 481     return DEFAULT_REMOTE_CONTRAST_SETTING;
 482 }
 483
 484 void lcd_remote_set_contrast(int val)
 485 {
 486     rc_status = (rc_status & ~RC_CONTRAST_MASK) | (val & RC_CONTRAST_MASK);
 487     rc_status |= RC_UPDATE_CONTROLLER;
 488 }
 489
 490 void lcd_remote_off(void)
 491 {
 492     /* should only be used to power off at shutdown */
 493     rc_status |= RC_POWER_OFF;
 494     semaphore_release(&rc_thread_wakeup);
 495
 496     /* wait until the things are powered off */
 497     while (rc_status & RC_DEV_INIT)
 498         sleep(HZ/10);
 499 }
 500
 501 void lcd_remote_on(void)
 502 {
 503     /* Only wake the remote thread if it's in the blocked state. */
 504     struct thread_entry *rc_thread = thread_id_entry(remote_thread_id);
 505     if (rc_thread->state == STATE_BLOCKED || (rc_status & RC_FORCE_DETECT))
 506     {
 507         rc_status &= ~RC_FORCE_DETECT;
 508         rc_status &= ~RC_POWER_OFF;
 509         semaphore_release(&rc_thread_wakeup);
 510     }
 511 }
 512
 513 bool remote_detect(void)
 514 {
 515     return (rc_status & RC_DETECTED);
 516 }
 517
 518 void lcd_remote_init_device(void)
 519 {
 520     /* reset */
 521     remote_dev_enable(false);
 522     rc_status |= RC_FORCE_DETECT; /* force detection at startup */
 523
 524     /* unknown */
 525     GPIO_SET_BITWISE(GPIOL_ENABLE, 0x80);
 526     GPIO_CLEAR_BITWISE(GPIOL_OUTPUT_VAL, 0x80);
 527     GPIO_SET_BITWISE(GPIOL_OUTPUT_EN, 0x80);
 528
 529     /* a thread is required to poll & update the remote */
 530     semaphore_init(&rc_thread_wakeup, 1, 0);
 531     remote_thread_id = create_thread(remote_thread, remote_stack,
 532                             sizeof(remote_stack), 0, remote_thread_name
 533                             IF_PRIO(, PRIORITY_SYSTEM)
 534                             IF_COP(, CPU));
 535 }
 536
 537 /* Update the display.
 538    This must be called after all other LCD functions that change the display. */
 539 void lcd_remote_update(void)
 540 {
 541     rc_status |= RC_UPDATE_LCD;
 542 }
 543
 544 /* Update a fraction of the display. */
 545 void lcd_remote_update_rect(int x, int y, int width, int height)
 546 {
 547     (void)x;
 548     (void)y;
 549     (void)width;
 550     (void)height;
 551
 552     rc_status |= RC_UPDATE_LCD;
 553 }
 554
 555 void _remote_backlight_on(void)
 556 {
 557     rc_status |= RC_BACKLIGHT_ON;
 558     rc_status |= RC_UPDATE_CONTROLLER;
 559 }
 560
 561 void _remote_backlight_off(void)
 562 {
 563     rc_status &= ~RC_BACKLIGHT_ON;
 564     rc_status |= RC_UPDATE_CONTROLLER;
 565 }