firmware/logf.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Daniel Stenberg
  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 /*
  23  * logf() logs entries in a circular buffer. Each logged string is null-terminated.
  24  *
  25  * When the length of log exceeds MAX_LOGF_SIZE bytes, the buffer wraps.
  26  *
  27  */
  28
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <stdarg.h>
  32 #include "config.h"
  33 #include "system.h"
  34 #include "font.h"
  35 #ifdef HAVE_REMOTE_LCD
  36 #include "lcd-remote.h"
  37 #endif
  38 #include "logf.h"
  39 #include "serial.h"
  40 #include "format.h"
  41
  42 #ifdef HAVE_USBSTACK
  43 #include "usb_core.h"
  44 #include "usbstack/usb_serial.h"
  45 #endif
  46
  47 #ifdef ROCKBOX_HAS_LOGDISKF
  48 #include "logdiskf.h"
  49 #include "file.h"
  50 #include "rbpaths.h"
  51 #include "ata_idle_notify.h"
  52
  53 unsigned char logdiskfbuffer[MAX_LOGDISKF_SIZE];
  54 int logdiskfindex;
  55 #endif
  56
  57 /* Only provide all this if asked to */
  58 #ifdef ROCKBOX_HAS_LOGF
  59
  60 #ifndef __PCTOOL__
  61 unsigned char logfbuffer[MAX_LOGF_SIZE];
  62 int logfindex;
  63 bool logfwrap;
  64 #endif
  65
  66 #ifdef HAVE_REMOTE_LCD
  67 static void displayremote(void)
  68 {
  69     /* TODO: we should have a debug option that enables/disables this! */
  70     int w, h, i;
  71     int fontnr;
  72     int cur_x, cur_y, delta_y, delta_x;
  73     struct font* font;
  74     int nb_lines;
  75     char buf[2];
  76     /* Memorize the pointer to the beginning of the last ... lines
  77        I assume delta_y >= 6 to avoid wasting memory and allocating memory dynamically
  78        I hope there is no font with height < 6 ! */
  79     const int NB_ENTRIES=LCD_REMOTE_HEIGHT / 6;
  80     int line_start_ptr[NB_ENTRIES];
  81
  82     fontnr = lcd_getfont();
  83     font = font_get(fontnr);
  84
  85     /* get the horizontal size of each line */
  86     font_getstringsize("A", NULL, &delta_y, fontnr);
  87
  88     /* font too small ? */
  89     if(delta_y < 6)
  90         return;
  91     /* nothing to print ? */
  92     if(logfindex == 0 && !logfwrap)
  93         return;
  94
  95     w = LCD_REMOTE_WIDTH;
  96     h = LCD_REMOTE_HEIGHT;
  97     nb_lines = 0;
  98
  99     if(logfwrap)
 100         i = logfindex;
 101     else
 102         i = 0;
 103
 104     cur_x = 0;
 105
 106     line_start_ptr[0] = i;
 107
 108     do
 109     {
 110         if(logfbuffer[i] == '\0')
 111         {
 112             line_start_ptr[++nb_lines % NB_ENTRIES] = i+1;
 113             cur_x = 0;
 114         }
 115         else
 116         {
 117             /* does character fit on this line ? */
 118             delta_x = font_get_width(font, logfbuffer[i]);
 119
 120             if(cur_x + delta_x > w)
 121             {
 122                 cur_x = 0;
 123                 line_start_ptr[++nb_lines % NB_ENTRIES] = i;
 124             }
 125             /* update pointer */
 126             cur_x += delta_x;
 127         }
 128         i++;
 129         if(i >= MAX_LOGF_SIZE)
 130             i = 0;
 131     } while(i != logfindex);
 132
 133     lcd_remote_clear_display();
 134
 135     i = line_start_ptr[ MAX(nb_lines - h / delta_y, 0) % NB_ENTRIES];
 136     cur_x = 0;
 137     cur_y = 0;
 138     buf[1] = '\0';
 139
 140     do {
 141         if(logfbuffer[i] == '\0')
 142         {
 143             cur_y += delta_y;
 144             cur_x = 0;
 145         }
 146         else
 147         {
 148             /* does character fit on this line ? */
 149             delta_x = font_get_width(font, logfbuffer[i]);
 150
 151             if(cur_x + delta_x > w)
 152             {
 153                 cur_y += delta_y;
 154                 cur_x = 0;
 155             }
 156
 157             buf[0] = logfbuffer[i];
 158             lcd_remote_putsxy(cur_x, cur_y, buf);
 159             cur_x += delta_x;
 160         }
 161
 162         i++;
 163         if(i >= MAX_LOGF_SIZE)
 164             i = 0;
 165     } while(i != logfindex);
 166
 167     lcd_remote_update();
 168 }
 169 #else
 170 #define displayremote()
 171 #endif
 172
 173 #ifdef __PCTOOL__
 174 void _logf(const char *format, ...)
 175 {
 176     char buf[1024];
 177     va_list ap;
 178     va_start(ap, format);
 179
 180     vsnprintf(buf, sizeof buf, format, ap);
 181     printf("DEBUG: %s\n", buf);
 182 }
 183 #else
 184 static void check_logfindex(void)
 185 {
 186     if(logfindex >= MAX_LOGF_SIZE)
 187     {
 188         /* wrap */
 189         logfwrap = true;
 190         logfindex = 0;
 191     }
 192 }
 193
 194 static int logf_push(void *userp, unsigned char c)
 195 {
 196     (void)userp;
 197
 198     logfbuffer[logfindex++] = c;
 199     check_logfindex();
 200
 201 #if defined(HAVE_SERIAL) && !defined(SIMULATOR) && defined(LOGF_SERIAL)
 202     if(c != '\0')
 203     {
 204         char buf[2];
 205         buf[0] = c;
 206         buf[1] = '\0';
 207         serial_tx(buf);
 208     }
 209 #endif
 210
 211     return true;
 212 }
 213
 214 void _logf(const char *fmt, ...)
 215 {
 216     #ifdef USB_ENABLE_SERIAL
 217     int old_logfindex = logfindex;
 218     #endif
 219     va_list ap;
 220
 221     va_start(ap, fmt);
 222
 223 #if (CONFIG_PLATFORM & PLATFORM_HOSTED)
 224     char buf[1024];
 225     vsnprintf(buf, sizeof buf, fmt, ap);
 226     DEBUGF("%s\n", buf);
 227     /* restart va_list otherwise the result if undefined when vuprintf is called */
 228     va_end(ap);
 229     va_start(ap, fmt);
 230 #endif
 231
 232     vuprintf(logf_push, NULL, fmt, ap);
 233     va_end(ap);
 234
 235     /* add trailing zero */
 236     logf_push(NULL, '\0');
 237
 238 #if defined(HAVE_SERIAL) && !defined(SIMULATOR) && defined(LOGF_SERIAL)
 239     serial_tx("\r\n");
 240 #endif
 241 #ifdef USB_ENABLE_SERIAL
 242
 243     if(logfindex < old_logfindex)
 244     {
 245         usb_serial_send(logfbuffer + old_logfindex, MAX_LOGF_SIZE - old_logfindex);
 246         usb_serial_send(logfbuffer, logfindex - 1);
 247     }
 248     else
 249         usb_serial_send(logfbuffer + old_logfindex, logfindex - old_logfindex - 1);
 250     usb_serial_send("\r\n", 2);
 251 #endif
 252
 253     displayremote();
 254 }
 255 #endif
 256
 257 #endif
 258
 259 #ifdef ROCKBOX_HAS_LOGDISKF
 260 static int logdiskf_push(void *userp, unsigned char c)
 261 {
 262     (void)userp;
 263
 264     /*just stop logging if out of space*/
 265     if(logdiskfindex>=MAX_LOGDISKF_SIZE-1)
 266     {
 267         strcpy(&logdiskfbuffer[logdiskfindex-8], "LOGFULL");
 268         logdiskfindex=MAX_LOGDISKF_SIZE;
 269         return false;
 270     }
 271     logdiskfbuffer[logdiskfindex++] = c;
 272
 273     return true;
 274 }
 275
 276 void _logdiskf(const char* file, const char level, const char *fmt, ...)
 277 {
 278
 279     va_list ap;
 280
 281     va_start(ap, fmt);
 282     int len =strlen(file);
 283     if(logdiskfindex +len + 4 > MAX_LOGDISKF_SIZE-1)
 284     {
 285         strcpy(&logdiskfbuffer[logdiskfindex-8], "LOGFULL");
 286         logdiskfindex=MAX_LOGDISKF_SIZE;
 287         return;
 288     }
 289
 290     logdiskf_push(NULL, level);
 291     logdiskf_push(NULL, ' ');
 292     logdiskf_push(NULL, '[');
 293     strcpy(&logdiskfbuffer[logdiskfindex], file);
 294     logdiskfindex += len;
 295     logdiskf_push(NULL, ']');
 296
 297     vuprintf(logdiskf_push, NULL, fmt, ap);
 298     va_end(ap);
 299
 300
 301 }
 302 static void flush_buffer(void* data)
 303 {
 304     (void)data;
 305     int fd;
 306     if(logdiskfindex < 1)
 307         return;
 308
 309     fd = open(HOME_DIR"/rockbox_log.txt", O_RDWR | O_CREAT | O_APPEND, 0666);
 310     if (fd < 0)
 311         return;
 312
 313     write(fd, logdiskfbuffer, logdiskfindex);
 314     close(fd);
 315
 316     logdiskfindex = 0;
 317 }
 318
 319 void init_logdiskf()
 320 {
 321     register_storage_idle_func(flush_buffer);
 322 }
 323 #endif