OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [or1ksim/] [peripheral/] [fb.c] - Blame information for rev 228

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 19 jeremybenn
/* fb.c -- Simple frame buffer
2
 
3
   Copyright (C) 2001 Marko Mlinar, markom@opencores.org
4
   Copyright (C) 2008 Embecosm Limited
5
 
6
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
7
 
8
   This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.
9
 
10
   This program is free software; you can redistribute it and/or modify it
11
   under the terms of the GNU General Public License as published by the Free
12
   Software Foundation; either version 3 of the License, or (at your option)
13
   any later version.
14
 
15
   This program is distributed in the hope that it will be useful, but WITHOUT
16
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18
   more details.
19
 
20
   You should have received a copy of the GNU General Public License along
21
   with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
/* This program is commented throughout in a fashion suitable for processing
24
   with Doxygen. */
25
 
26
 
27
/* Autoconf and/or portability configuration */
28
#include "config.h"
29
#include "port.h"
30
 
31
/* System includes */
32
#include <stdlib.h>
33
#include <stdio.h>
34
 
35
/* Package includes */
36
#include "arch.h"
37
#include "sim-config.h"
38
#include "abstract.h"
39
#include "sched.h"
40
#include "toplevel-support.h"
41
 
42
 
43
#define FB_SIZEX           640
44
#define FB_SIZEY           480
45
 
46
#define CAM_SIZEX          352
47
#define CAM_SIZEY          288
48
 
49
/*! Relative amount of time spent in refresh */
50
#define REFRESH_DIVIDER     20
51
 
52
#define FB_CTRL            0x0000
53
#define FB_BUFADDR         0x0004
54
#define FB_CAMBUFADDR      0x0008
55
#define FB_CAMPOSADDR      0x000c
56
#define FB_PAL             0x0400
57
 
58
#define FB_WRAP (512*1024)
59
 
60
struct fb_state
61
{
62
  int enabled;
63
  unsigned long pal[256];
64
  int ctrl;
65
  int pic;
66
  int in_refresh;
67
  int refresh_count;
68
  oraddr_t addr;
69
  oraddr_t cam_addr;
70
  int camerax;
71
  int cameray;
72
  int camera_pos;
73
  oraddr_t baseaddr;
74
  int refresh;
75
  int refresh_rate;
76
  char *filename;
77
};
78
 
79
static void
80
change_buf_addr (struct fb_state *fb, oraddr_t addr)
81
{
82
  fb->addr = addr;
83
}
84
 
85
/* Write a register */
86
static void
87
fb_write32 (oraddr_t addr, uint32_t value, void *dat)
88
{
89
  struct fb_state *fb = dat;
90
 
91
  switch (addr)
92
    {
93
    case FB_CTRL:
94
      fb->ctrl = value;
95
      break;
96
    case FB_BUFADDR:
97
      change_buf_addr (fb, value);
98
      break;
99
    case FB_CAMBUFADDR:
100
      fb->cam_addr = value;
101
      break;
102
    case FB_CAMPOSADDR:
103
      fb->camera_pos = value;
104
      fb->camerax = value % FB_SIZEX;
105
      fb->cameray = value / FB_SIZEX;
106
      break;
107
    default:
108
      addr -= FB_PAL;
109
      addr /= 4;
110
      if (addr < 0 || addr >= 256)
111
        {
112
          fprintf (stderr, "Write out of palette buffer (0x%" PRIxADDR ")!\n",
113
                   addr);
114
        }
115
      else
116
        fb->pal[addr] = value;
117
      break;
118
    }
119
}
120
 
121
/* Read a register */
122
static oraddr_t
123
fb_read32 (oraddr_t addr, void *dat)
124
{
125
  struct fb_state *fb = dat;
126
 
127
  switch (addr)
128
    {
129
    case FB_CTRL:
130
      return (fb->ctrl & ~0xff000000) | (fb->
131
                                         in_refresh ? 0x80000000 : 0) |
132
        ((unsigned long) (fb->refresh_count & 0x7f) << 24);
133
      break;
134
    case FB_BUFADDR:
135
      return fb->addr;
136
      break;
137
    case FB_CAMBUFADDR:
138
      return fb->cam_addr;
139
      break;
140
    case FB_CAMPOSADDR:
141
      return fb->camera_pos;
142
      break;
143
    default:
144
      addr -= FB_PAL;
145
      addr /= 4;
146
      if (addr < 0 || addr >= 256)
147
        {
148
          fprintf (stderr, "Read out of palette buffer (0x%" PRIxADDR ")!\n",
149
                   addr);
150
          return 0;
151
        }
152
      else
153
        return fb->pal[addr];
154
    }
155
}
156
 
157
/* define these also for big endian */
158
#if __BIG_ENDIAN__
159
#define CNV32(x) (\
160
     ((((x) >> 24) & 0xff) << 0)\
161
   | ((((x) >> 16) & 0xff) << 8)\
162
   | ((((x) >> 8) & 0xff) << 16)\
163
   | ((((x) >> 0) & 0xff) << 24))
164
#define CNV16(x) (\
165
     ((((x) >> 8) & 0xff) << 0)\
166
   | ((((x) >> 0) & 0xff) << 8))
167
#else
168
#define CNV16(x) (x)
169
#define CNV32(x) (x)
170
#endif
171
 
172
/* Dumps a bmp file, based on current image */
173
static int
174
fb_dump_image8 (struct fb_state *fb, char *filename)
175
{
176
  int sx = FB_SIZEX;
177
  int sy = FB_SIZEY;
178
  int i, x = 0, y = 0;
179
  FILE *fo;
180
 
181
  unsigned short int u16;
182
  unsigned long int u32;
183
 
184
  if (config.sim.verbose)
185
    PRINTF ("Creating %s...", filename);
186
  fo = fopen (filename, "wb+");
187
  u16 = CNV16 (19778);          /* BM */
188
  if (!fwrite (&u16, 2, 1, fo))
189
    return 1;
190
  u32 = CNV32 (14 + 40 + sx * sy + 1024);       /* size */
191
  if (!fwrite (&u32, 4, 1, fo))
192
    return 1;
193
  u32 = CNV32 (0);               /* reserved */
194
  if (!fwrite (&u32, 4, 1, fo))
195
    return 1;
196
  u32 = 14 + 40 + 1024;         /* offset */
197
  if (!fwrite (&u32, 4, 1, fo))
198
    return 1;
199
 
200
  u32 = CNV32 (40);             /* header size */
201
  if (!fwrite (&u32, 4, 1, fo))
202
    return 1;
203
  u32 = CNV32 (sx);             /* width */
204
  if (!fwrite (&u32, 4, 1, fo))
205
    return 1;
206
  u32 = CNV32 (sy);             /* height */
207
  if (!fwrite (&u32, 4, 1, fo))
208
    return 1;
209
  u16 = CNV16 (1);              /* planes */
210
  if (!fwrite (&u16, 2, 1, fo))
211
    return 1;
212
  u16 = CNV16 (8);              /* bits */
213
  if (!fwrite (&u16, 2, 1, fo))
214
    return 1;
215
  u32 = CNV32 (0);               /* compression */
216
  if (!fwrite (&u32, 4, 1, fo))
217
    return 1;
218
  u32 = CNV32 (x * y);          /* image size */
219
  if (!fwrite (&u32, 4, 1, fo))
220
    return 1;
221
  u32 = CNV32 (2835);           /* x resolution */
222
  if (!fwrite (&u32, 4, 1, fo))
223
    return 1;
224
  u32 = CNV32 (2835);           /* y resolution */
225
  if (!fwrite (&u32, 4, 1, fo))
226
    return 1;
227
  u32 = CNV32 (0);               /* ncolours = 0; should be generated */
228
  if (!fwrite (&u32, 4, 1, fo))
229
    return 1;
230
  u32 = CNV32 (0);               /* important colours; all are important */
231
  if (!fwrite (&u32, 4, 1, fo))
232
    return 1;
233
 
234
  for (i = 0; i < 256; i++)
235
    {
236
      unsigned long val, d;
237
      d = fb->pal[i];
238
#if 1
239
      val = ((d >> 0) & 0x1f) << 3;      /* Blue */
240
      val |= ((d >> 5) & 0x3f) << 10;   /* Green */
241
      val |= ((d >> 11) & 0x1f) << 19;  /* Red */
242
#else
243
      val = CNV32 (pal[i]);
244
#endif
245
      if (!fwrite (&val, 4, 1, fo))
246
        return 1;
247
    }
248
 
249
  if (config.sim.verbose)
250
    PRINTF ("(%i,%i)", sx, sy);
251
  /* Data is stored upside down */
252
  for (y = sy - 1; y >= 0; y--)
253
    {
254
      int align = (4 - sx) % 4;
255
      int zero = CNV32 (0);
256
      int add;
257
      while (align < 0)
258
        align += 4;
259
      for (x = 0; x < sx; x++)
260
        {
261
          add =
262
            (fb->
263
             addr & ~(FB_WRAP - 1)) | ((fb->addr + y * sx + x) & (FB_WRAP -
264
                                                                  1));
265
          fputc (eval_direct8 (add, 0, 0), fo);
266
        }
267
      if (align && !fwrite (&zero, align, 1, fo))
268
        return 1;
269
    }
270
 
271
  if (config.sim.verbose)
272
    PRINTF ("DONE\n");
273
  fclose (fo);
274
  return 0;
275
}
276
 
277
/* Dumps a bmp file, based on current image */
278
static int
279
fb_dump_image24 (struct fb_state *fb, char *filename)
280
{
281
  int sx = FB_SIZEX;
282
  int sy = FB_SIZEY;
283
  int x = 0, y = 0;
284
  FILE *fo;
285
 
286
  unsigned short int u16;
287
  unsigned long int u32;
288
 
289
  if (config.sim.verbose)
290
    PRINTF ("Creating %s...", filename);
291
  fo = fopen (filename, "wb+");
292
  u16 = CNV16 (19778);          /* BM */
293
  if (!fwrite (&u16, 2, 1, fo))
294
    return 1;
295
  u32 = CNV32 (14 + 40 + sx * sy * 3);  /* size */
296
  if (!fwrite (&u32, 4, 1, fo))
297
    return 1;
298
  u32 = CNV32 (0);               /* reserved */
299
  if (!fwrite (&u32, 4, 1, fo))
300
    return 1;
301
  u32 = 14 + 40;                /* offset */
302
  if (!fwrite (&u32, 4, 1, fo))
303
    return 1;
304
 
305
  u32 = CNV32 (40);             /* header size */
306
  if (!fwrite (&u32, 4, 1, fo))
307
    return 1;
308
  u32 = CNV32 (sx);             /* width */
309
  if (!fwrite (&u32, 4, 1, fo))
310
    return 1;
311
  u32 = CNV32 (sy);             /* height */
312
  if (!fwrite (&u32, 4, 1, fo))
313
    return 1;
314
  u16 = CNV16 (1);              /* planes */
315
  if (!fwrite (&u16, 2, 1, fo))
316
    return 1;
317
  u16 = CNV16 (24);             /* bits */
318
  if (!fwrite (&u16, 2, 1, fo))
319
    return 1;
320
  u32 = CNV32 (0);               /* compression */
321
  if (!fwrite (&u32, 4, 1, fo))
322
    return 1;
323
  u32 = CNV32 (x * y * 3);      /* image size */
324
  if (!fwrite (&u32, 4, 1, fo))
325
    return 1;
326
  u32 = CNV32 (2835);           /* x resolution */
327
  if (!fwrite (&u32, 4, 1, fo))
328
    return 1;
329
  u32 = CNV32 (2835);           /* y resolution */
330
  if (!fwrite (&u32, 4, 1, fo))
331
    return 1;
332
  u32 = CNV32 (0);               /* ncolours = 0; should be generated */
333
  if (!fwrite (&u32, 4, 1, fo))
334
    return 1;
335
  u32 = CNV32 (0);               /* important colours; all are important */
336
  if (!fwrite (&u32, 4, 1, fo))
337
    return 1;
338
 
339
  if (config.sim.verbose)
340
    PRINTF ("(%i,%i)", sx, sy);
341
  /* Data is stored upside down */
342
  for (y = sy - 1; y >= 0; y--)
343
    {
344
      unsigned char line[FB_SIZEX][3];
345
      for (x = 0; x < sx; x++)
346
        if (y >= fb->cameray && x >= fb->camerax
347
            && y < fb->cameray + CAM_SIZEY && x < fb->camerax + CAM_SIZEX)
348
          {
349
            int add =
350
              (fb->cam_addr +
351
               (x - fb->camerax + (y - fb->cameray) * CAM_SIZEX) * 2) ^ 2;
352
            unsigned short d = eval_direct16 (add, 0, 0);
353
            line[x][0] = ((d >> 0) & 0x1f) << 3;  /* Blue */
354
            line[x][1] = ((d >> 5) & 0x3f) << 2;        /* Green */
355
            line[x][2] = ((d >> 11) & 0x1f) << 3;       /* Red */
356
          }
357
        else
358
          {
359
            int add =
360
              (fb->
361
               addr & ~(FB_WRAP - 1)) | ((fb->addr + y * sx + x) & (FB_WRAP -
362
                                                                    1));
363
            unsigned short d = fb->pal[eval_direct8 (add, 0, 0)];
364
            line[x][0] = ((d >> 0) & 0x1f) << 3;  /* Blue */
365
            line[x][1] = ((d >> 5) & 0x3f) << 2;        /* Green */
366
            line[x][2] = ((d >> 11) & 0x1f) << 3;       /* Red */
367
          }
368
      if (!fwrite (line, sizeof (line), 1, fo))
369
        return 1;
370
    }
371
 
372
  if (config.sim.verbose)
373
    PRINTF ("DONE\n");
374
  fclose (fo);
375
  return 0;
376
}
377
 
378
static void
379
fb_job (void *dat)
380
{
381
  struct fb_state *fb = dat;
382
 
383
  if (fb->refresh)
384
    {
385
      /* dump the image? */
386
      if (fb->ctrl & 1)
387
        {
388
          char temp[STR_SIZE];
389
          sprintf (temp, "%s%04i.bmp", fb->filename, fb->pic);
390
          if (fb->ctrl & 2)
391
            fb_dump_image24 (fb, temp);
392
          else
393
            fb_dump_image8 (fb, temp);
394
          fb->pic++;
395
        }
396
      SCHED_ADD (fb_job, dat, fb->refresh_rate / REFRESH_DIVIDER);
397
      fb->in_refresh = 0;
398
      fb->refresh = 0;
399
    }
400
  else
401
    {
402
      fb->refresh_count++;
403
      fb->refresh = 1;
404
      SCHED_ADD (fb_job, dat, fb->refresh_rate / REFRESH_DIVIDER);
405
    }
406
}
407
 
408
/* Reset all FBs */
409
static void
410
fb_reset (void *dat)
411
{
412
  struct fb_state *fb = dat;
413
  int i;
414
 
415
  fb->pic = 0;
416
  fb->addr = 0;
417
  fb->ctrl = 0;
418
 
419
  for (i = 0; i < 256; i++)
420
    fb->pal[i] = (i << 16) | (i << 8) | (i << 0);
421
 
422
  SCHED_ADD (fb_job, dat, fb->refresh_rate);
423
  fb->refresh = 0;
424
}
425
 
426
/*-----------------------------------------------------[ FB configuration ]---*/
427
static void
428
fb_enabled (union param_val val, void *dat)
429
{
430
  struct fb_state *fb = dat;
431
  fb->enabled = val.int_val;
432
}
433
 
434
 
435
static void
436
fb_baseaddr (union param_val val, void *dat)
437
{
438
  struct fb_state *fb = dat;
439
  fb->baseaddr = val.addr_val;
440
}
441
 
442
 
443
static void
444
fb_refresh_rate (union param_val val, void *dat)
445
{
446
  struct fb_state *fb = dat;
447
  fb->refresh_rate = val.int_val;
448
}
449
 
450
 
451
/*---------------------------------------------------------------------------*/
452
/*!Set the frame buffer output file
453
 
454
   Free any previously allocated value.
455
 
456
   @param[in] val  The value to use
457
   @param[in] dat  The config data structure                                 */
458
/*---------------------------------------------------------------------------*/
459
static void
460
fb_filename (union param_val  val,
461
             void            *dat)
462
{
463
  struct fb_state *fb = dat;
464
 
465
  if (NULL != fb->filename)
466
    {
467
      free (fb->filename);
468
      fb->filename = NULL;
469
    }
470
 
471
  if (!(fb->filename = strdup (val.str_val)))
472
    {
473
      fprintf (stderr, "Peripheral FB: Run out of memory\n");
474
      exit (-1);
475
    }
476
}       /* fb_filename() */
477
 
478
 
479
/*---------------------------------------------------------------------------*/
480
/*!Initialize a new frame buffer configuration
481
 
482
   ALL parameters are set explicitly to default values.                      */
483
/*---------------------------------------------------------------------------*/
484
static void *
485
fb_sec_start ()
486
{
487
  struct fb_state *new = malloc (sizeof (struct fb_state));
488
 
489
  if (!new)
490
    {
491
      fprintf (stderr, "Peripheral FB: Run out of memory\n");
492
      exit (-1);
493
    }
494
 
495
  new->enabled       = 1;
496
  new->baseaddr      = 0;
497
  new->refresh_rate  = 1000000000000ULL / 50ULL / config.sim.clkcycle_ps;
498
  new->filename      = strdup ("fb_out");
499
 
500
  new->ctrl          = 0;
501
  new->pic           = 0;
502
  new->in_refresh    = 1;
503
  new->refresh_count = 0;
504
  new->addr          = 0;
505
  new->cam_addr      = 0;
506
  new->camerax       = 0;
507
  new->cameray       = 0;
508
  new->camera_pos    = 0;
509
 
510
  return new;
511
 
512
}       /* fb_sec_start() */
513
 
514
 
515
static void
516
fb_sec_end (void *dat)
517
{
518
  struct fb_state *fb = dat;
519
  struct mem_ops ops;
520
 
521
  if (!fb->enabled)
522
    {
523
      free (fb->filename);
524
      free (fb);
525
      return;
526
    }
527
 
528
  memset (&ops, 0, sizeof (struct mem_ops));
529
 
530
  ops.readfunc32 = fb_read32;
531
  ops.writefunc32 = fb_write32;
532
  ops.write_dat32 = dat;
533
  ops.read_dat32 = dat;
534
 
535
  /* FIXME: Correct delay? */
536
  ops.delayr = 2;
537
  ops.delayw = 2;
538
 
539
  reg_mem_area (fb->baseaddr, FB_PAL + 256 * 4, 0, &ops);
540
 
541
  reg_sim_reset (fb_reset, dat);
542
}
543
 
544
void
545
reg_fb_sec ()
546
{
547
  struct config_section *sec =
548
    reg_config_sec ("fb", fb_sec_start, fb_sec_end);
549
 
550 224 jeremybenn
  reg_config_param (sec, "baseaddr",     PARAMT_ADDR, fb_baseaddr);
551
  reg_config_param (sec, "enabled",      PARAMT_INT,  fb_enabled);
552
  reg_config_param (sec, "refresh_rate", PARAMT_INT,  fb_refresh_rate);
553
  reg_config_param (sec, "txfile",       PARAMT_STR,  fb_filename);
554
  reg_config_param (sec, "filename",     PARAMT_STR,  fb_filename);
555 19 jeremybenn
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.