display/display.c

Go to the documentation of this file.

/*
 * File Name  : display.c
 *
 * Description: Delta display utility
 */

/*
 * This file is part of display.
 *
 * display is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * display is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <linux/fb.h>

#include "delta.h"

int display_image(int fbDev, unsigned char *screen_memory, char * filename, int waveform, struct fb_var_screeninfo *screen_info )
{    
    int ret;
    FILE *f;
    struct display_update_info info;
    unsigned char *tempmem = NULL;
    
    info.waveform = waveform;
    info.color = 0;

    /* Allocate temp buffer to hold the file data */
    if ( screen_info )
    {
        tempmem = malloc( screen_info->xres * screen_info->yres);
    }
    else
    {
        printf("Invalid screen info\n");
        return -1;
    }        
    
    if (tempmem == NULL)
    {
        printf("Not enough memory\n");
        return -1;
    }

    /* open the image */
    if (!(f = fopen(filename, "r")))
    {
        printf("Error opening file %s\n", filename);
        return -1;
    }

    printf("Read %ld bytes\n", (unsigned long)fread(tempmem, 1, screen_info->xres * screen_info->yres, f));

    /* close the image */
    fclose(f);
    memcpy(screen_memory, tempmem, screen_info->xres * screen_info->yres);
    free(tempmem);

    printf("Displaying %s\n", filename);

    /* tell the display to update itself */
    if ((ret = ioctl(fbDev, FBIO_DELTA_UPDATE_DISPLAY, &info)))
    {
        printf("Error sending FBIO_DISPLAY: %x\n", ret);
    }
    
    return ret;
}


int downloadwaves(int fbDev, char * filename, int from_sysset)
{
    int ret;
    FILE *f;
    struct wave_info info;
    
    /* open the wave file */
    if (!(f = fopen(filename, "r")))
    {
        printf("Error opening file %s\n", filename);
        return -1;
    }

    if (from_sysset)
    {
      fseek(f, 128*(1<<10), SEEK_SET);
    }
    info.wave = malloc(128 * 1024);
    if (info.wave == NULL)
    {
        printf("Not enough memory\n");
        return -1;
    }
    info.size = fread(info.wave, 1, WAVEFORM_SIZE, f);

    /* close the image */
    fclose(f);

    if ((ret = ioctl(fbDev, FBIO_DELTA_UPLOADWAVES, &info)) != 0)
    {
        printf("Error sending FBIO_DELTA_UPLOADWAVES: %x\n", ret);
    }
    free(info.wave);

    return ret;
}


int deltainit(int fbDev)
{
    int ret = 0;
    
    if ((ret = ioctl(fbDev, FBIO_DELTA_INIT, NULL)) != 0)
    {
        printf("Error sending FBIO_DELTA_INIT: %x\n", ret);
    }

    return ret;
}


int deltaregdump(int fbDev)
{
    int ret = 0;
    
    if ((ret = ioctl(fbDev, FBIO_DELTA_REG_DUMP, NULL)) != 0)
    {
        printf("Error sending FBIO_DELTA_REG_DUMP: %x\n", ret);
    }

    return ret;
}


int main (int argc, char * argv[])
{
    int fbDev;
    int ret;
    unsigned char *screen_memory;
    FILE *f;
    struct display_update_info info;
    char serial[16];
    double vcom = 0;
    signed long vcom_int;
    int waveform;
    unsigned int fpga_version;
    struct fb_var_screeninfo var;

    fbDev = open ("/dev/fb0", O_RDWR);
    if (fbDev == -1)   
    {
        printf("Error opening framebufferdevice. # mknod /dev/fb0 c 29 0\n");
        exit(-1);
    }

    ret = ioctl(fbDev, FBIOGET_VSCREENINFO, &var);
#ifdef DEBUG
    fprintf(stderr, ">> fb geometry %u %u %u %u %u\n", var.xres, var.yres, 
            var.xres_virtual, var.yres_virtual, var.bits_per_pixel);
#endif    
    if((ret == -1) || (var.xres == 0) || (var.yres == 0))
    {
        printf("Failed to read out framebuffer screen info\n");        
        exit(-1);
    }
    
    screen_memory = (unsigned char *) mmap(0, var.xres * var.yres, PROT_READ | PROT_WRITE, MAP_SHARED, fbDev, 0);
    if(screen_memory == ((void *)-1))
    {
        perror("\nError mmap-ping\n");
        exit(-1);
    }

    if(argc < 2)
        goto usage;

    if(!strcasecmp(argv[1], "REGDUMP"))
    {
        if(argc != 2)
            goto usage;
        /* Delta register dump */
        printf("Delta registers dump:\n");
        deltaregdump(fbDev);
        printf("OK\n");
    }
    else if(!strcasecmp(argv[1], "REGWRITE"))
    {
      unsigned char addr, value;
      unsigned long addr_value;
      unsigned int tmp;

        if(argc != 4)
            goto usage;

      sscanf(argv[2], "%x", &tmp);
      addr = tmp & 0xFF;

      sscanf(argv[3], "%x", &tmp);
      value = tmp & 0xFF;

      addr_value = (addr << 16) | value;

        ret = ioctl(fbDev, FBIO_DELTA_REG_WRITE, &addr_value);
        if (ret == -1)
        {
            printf("Error writing register\n");
        }
    }
    else if(!strcasecmp(argv[1], "INIT"))
    {
        if(argc != 2)
            goto usage;
        /* Delta init */
        printf("Initializing Delta....  ");
        deltainit(fbDev);
        printf("OK\n");
    }
    else if(!strcasecmp(argv[1], "SYSWAVES"))
    {
        if(argc != 3)
            goto usage;
        /* Upload the waves */
        printf("Uploading waves from sysset....  ");
        downloadwaves(fbDev, argv[2], 1);
        printf("OK\n");
    }
    else if(!strcasecmp(argv[1], "WAVES"))
    {
        if(argc != 3)
            goto usage;
        /* Upload the waves */
        printf("Uploading waves....  ");
        downloadwaves(fbDev, argv[2], 0);
        printf("OK\n");
    }
    else if(!strcasecmp(argv[1], "ERASE"))
    {
        if(argc != 3)
            goto usage;
        /* Upload the waves */
        printf("Erasing display....  ");
        info.waveform = 1;
        info.color = atoi(argv[2]);
        if(info.color < 0) 
            info.color = 0;
        if(info.color >15) 
            info.color = 15;
        ret=ioctl(fbDev, FBIO_DELTA_ERASE, &info);       
        printf("OK\n");
    }
    else if(!strcasecmp(argv[1], "UPDATE"))
    {
        if(argc < 3)
            goto usage;
        if(argc == 4)
            waveform = atoi(argv[3]);
        else
            waveform = 1;
        /* Upload the waves */
        printf("Updating display.... ");
        /* map the framebuffer memory */
        ret = display_image(fbDev, screen_memory, argv[2], waveform, &var);
        munmap(screen_memory, var.xres * var.yres);
        printf("OK\n");
    }
    else if(!strcasecmp(argv[1], "SERIAL"))
    {
        if(argc != 2)
            goto usage;
        f = fopen("/sys/bus/w1/devices/w1_bus_master1/w1_master_slaves", "r");
        fgets(serial, 16, f);            
        fclose(f);
        printf("Display serial: %s\n", serial); 
    }
    else if(!strncasecmp(argv[1], "VCOM_SET", 5))
    {
        if(argc != 3)
            goto usage;
        vcom = atof(argv[2]);
        if(vcom < -5)
            vcom = -5;
        if(vcom > 5)
            vcom = 5;
        vcom_int = (signed long)(1000 * vcom);
        ret = ioctl(fbDev, FBIO_DETA_VCOM_SET, &vcom_int);
        if (ret == -1)
        {
            printf("Error setting VCOM\n");
        }
    }
    else if(!strncasecmp(argv[1], "FPGA_VER", 8))
    {
        if(argc != 2)
            goto usage;
        ret = ioctl(fbDev, FBIO_DETA_FPGA_VERSION, &fpga_version);
        if (ret == -1)
        {
            printf("Error getting FPGA version\n");
        }
        else
        {
            printf("%04X\n", fpga_version);
        }
    }
    else if (!strncasecmp(argv[1], "XRES", 4))
    {
        printf("%d\n", var.xres);
    }
    else if (!strncasecmp(argv[1], "YRES", 4))
    {
        printf("%d\n", var.yres);
    }
    else
    {
        printf("Unknow command: %s\n\n", argv[1]);
        munmap(screen_memory, var.xres * var.yres);
        exit(-1);
    }
    munmap(screen_memory, var.xres * var.yres);
    return ret;

usage:
    printf("Usage: %s COMMAND [parameter]\n\n", argv[0]);
    printf("Valid commands are:\n");
    printf(" INIT     - Initialise Delta\n");
    printf(" WAVES    - Download wave file specified as parameter to Delta\n");
    printf(" SYSWAVES - Download wave file from sysset partition to Delta\n");
    printf(" ERASE    - Erase display to specified color\n");
    printf(" UPDATE   - Update display with picture\n");
    printf(" SERIAL   - Get display serila number\n");
    printf(" VCOM_SET - Set display VCOM voltage\n");
    printf(" FPGA_VER - Get display FPGA version\n");
    printf(" XRES     - Get display X-resolution\n");
    printf(" YRES     - Get display Y-resolution\n");
    printf(" REGDUMP             - Delta register dump\n");
    printf(" REGWRITE addr value - Delta register write\n");
    munmap(screen_memory, var.xres * var.yres);
    exit(-1);
}