/*

 * GraphLCD driver library

 *

 * serdisp.h  -  include support for displays supported by serdisplib (if library is installed)

 *               http://serdisplib.sourceforge.net

 *

 * This file is released under the GNU General Public License. Refer

 * to the COPYING file distributed with this package.

 *

 * (c) 2003-2005 Wolfgang Astleitner <mrwastl AT users.sourceforge.net>

 */

#include <stdio.h>

#include <stdlib.h>

#include <syslog.h>

#include <dlfcn.h>

#include "common.h"

#include "config.h"

#include "serdisp.h"

#define SERDISP_VERSION(a,b) ((long)(((a) << 8) + (b)))

#define SERDISP_VERSION_GET_MAJOR(_c)  ((int)( (_c) >> 8 ))

#define SERDISP_VERSION_GET_MINOR(_c)  ((int)( (_c) & 0xFF ))

// taken from serdisp_control.h

#define FEATURE_CONTRAST  0x01

#define FEATURE_REVERSE   0x02

#define FEATURE_BACKLIGHT 0x03

#define FEATURE_ROTATE    0x04

#define SD_COL_BLACK      0xFF000000

namespace GLCD

{

cDriverSerDisp::cDriverSerDisp(cDriverConfig * config)

:   config(config)

{

    oldConfig = new cDriverConfig(*config);

    dd = (void *) NULL;

}

cDriverSerDisp::~cDriverSerDisp(void)

{

    delete oldConfig;

}

int cDriverSerDisp::Init(void)

{

    char* errmsg; // error message returned by dlerror()

    std::string controller;

    std::string optionstring = "";

    std::string wiringstring;

    // dynamically load serdisplib using dlopen() & co.

    sdhnd = dlopen("libserdisp.so", RTLD_LAZY);

    if (!sdhnd) { // try /usr/local/lib

        sdhnd = dlopen("/usr/local/lib/libserdisp.so", RTLD_LAZY);

    }

    if (!sdhnd) { // serdisplib seems not to be installed

        syslog(LOG_ERR, "%s: error: unable to dynamically load library '%s'. Err: %s (cDriver::Init)\n",

        config->name.c_str(), "libserdisp.so", "not found");

        return -1;

    }

    dlerror(); // clear error code

    /* pre-init some flags, function pointers, ... */

    supports_options = 0;

    fg_colour = 1;

    bg_colour = -1;

    // get serdisp version

    fp_serdisp_getversioncode = (long int (*)()) dlsym(sdhnd, "serdisp_getversioncode");

    if (dlerror()) { // no serdisp_getversioncode() -> version of serdisplib is < 1.95

        syslog(LOG_DEBUG, "%s: INFO: symbol serdisp_getversioncode unknown: autodetecting pre 1.95 serdisplib version (cDriver::Init)\n",

        config->name.c_str());

        fp_SDCONN_open = (void*(*)(const char*)) dlsym(sdhnd, "SDCONN_open");

        if (dlerror()) { // no SDCONN_open() -> version of serdisplib is < 1.93

            serdisp_version = SERDISP_VERSION(1,92);

            syslog(LOG_DEBUG, "%s: INFO: detected serdisplib version <= 1.92 (cDriver::Init)\n", config->name.c_str());

            fp_PP_open = (void*(*)(const char*))dlsym(sdhnd, "PP_open");

            if ( (errmsg = dlerror()) != NULL  ) { // should not happen

                syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                    config->name.c_str(), "PP_open", errmsg);

                return -1;

            }

            fp_PP_close = (void*(*)(void*))dlsym(sdhnd, "PP_close");

            if ( (errmsg = dlerror()) != NULL  ) { // should not happen

                syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                    config->name.c_str(), "PP_close", errmsg);

                return -1;

            }

        } else {

            serdisp_version = SERDISP_VERSION(1,94);  // no serdisp_getversioncode, but SDCONN_open: 1.93 or 1.94

            syslog(LOG_DEBUG, "%s: INFO: detected serdisplib version 1.93 or 1.94 (cDriver::Init)\n", config->name.c_str());

            fp_serdisp_quit = (void (*)(void*)) dlsym(sdhnd, "serdisp_quit");

            if ( (errmsg = dlerror()) != NULL  ) { // should not happen

                syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                    config->name.c_str(), "serdisp_quit", errmsg);

                return -1;

            }

        }

        fp_serdisp_setpixcol = (void (*)(void*, int, int, long int)) dlsym(sdhnd, "serdisp_setpixel");

        if ( (errmsg = dlerror()) != NULL  ) { // should not happen

            syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                config->name.c_str(), "serdisp_setpixel", errmsg);

            return -1;

        }

        fg_colour = 1; /* set foreground to 'pixel on' */

    } else {  // serdisp version >= 1.95

        serdisp_version = fp_serdisp_getversioncode();

        syslog(LOG_DEBUG, "%s: INFO: detected serdisplib version %d.%d (cDriver::Init)\n",

            config->name.c_str(), SERDISP_VERSION_GET_MAJOR(serdisp_version), SERDISP_VERSION_GET_MINOR(serdisp_version));

        fp_SDCONN_open = (void*(*)(const char*)) dlsym(sdhnd, "SDCONN_open");

        if ( (errmsg = dlerror()) != NULL  ) { // should not happen

            syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                config->name.c_str(), "SDCONN_open", errmsg);

            return -1;

        }

        fp_serdisp_quit = (void (*)(void*)) dlsym(sdhnd, "serdisp_quit");

        if ( (errmsg = dlerror()) != NULL  ) { // should not happen

            syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                config->name.c_str(), "serdisp_quit", errmsg);

            return -1;

        }

        fp_serdisp_setpixcol = (void (*)(void*, int, int, long int)) dlsym(sdhnd, "serdisp_setcolour");

        if ( (errmsg = dlerror()) != NULL  ) { // should not happen

            syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                config->name.c_str(), "serdisp_setcolour", errmsg);

            return -1;

        }

        fg_colour = SD_COL_BLACK; /* set foreground colour to black */

        if (serdisp_version >= SERDISP_VERSION(1,96) ) {

            supports_options = 1;

            fp_serdisp_isoption = (int (*)(void*, const char*)) dlsym(sdhnd, "serdisp_isoption");

            if ( (errmsg = dlerror()) != NULL  ) { // should not happen

                syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                    config->name.c_str(), "serdisp_isoption", errmsg);

                return -1;

            }

            fp_serdisp_setoption = (void (*)(void*, const char*, long int)) dlsym(sdhnd, "serdisp_setoption");

            if ( (errmsg = dlerror()) != NULL  ) { // should not happen

                syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

                    config->name.c_str(), "serdisp_setoption", errmsg);

                return -1;

            }

        } /* >= 1.96 */

    }

    // load other symbols that will be required

    fp_serdisp_init = (void*(*)(void*, const char*, const char*)) dlsym(sdhnd, "serdisp_init");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_init", errmsg);

        return -1;

    }

    fp_serdisp_rewrite = (void (*)(void*)) dlsym(sdhnd, "serdisp_rewrite");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_rewrite", errmsg);

        return -1;

    }

    fp_serdisp_update = (void (*)(void*)) dlsym(sdhnd, "serdisp_update");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_update", errmsg);

        return -1;

    }

    fp_serdisp_clearbuffer = (void (*)(void*)) dlsym(sdhnd, "serdisp_clearbuffer");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_clearbuffer", errmsg);

        return -1;

    }

    fp_serdisp_feature = (int (*)(void*, int, int)) dlsym(sdhnd, "serdisp_feature");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_feature", errmsg);

        return -1;

    }

    fp_serdisp_close = (void (*)(void*))dlsym(sdhnd, "serdisp_close");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_close", errmsg);

        return -1;

    }

    fp_serdisp_getwidth = (int (*)(void*)) dlsym(sdhnd, "serdisp_getwidth");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_getwidth", errmsg);

        return -1;

    }

    fp_serdisp_getheight = (int (*)(void*)) dlsym(sdhnd, "serdisp_getheight");

    if ( (errmsg = dlerror()) != NULL  ) { // should not happen

        syslog(LOG_ERR, "%s: error: cannot load symbol %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), "serdisp_getheight", errmsg);

        return -1;

    }

    // done loading all required symbols

    // setting up the display

    width = 0;

    height = 0;

    for (unsigned int i = 0; i < config->options.size(); i++)

    {

        if (config->options[i].name == "Controller") {

            controller = config->options[i].value;

        } else if (config->options[i].name == "Options") {

            optionstring = config->options[i].value;

        } else if (config->options[i].name == "Wiring") {

            wiringstring = config->options[i].value;

        } else if (config->options[i].name == "FGColour") {

            fg_colour = strtoul(config->options[i].value.c_str(), (char **)NULL, 0);

            fg_colour |= 0xFF000000L;  /* force alpha to 0xFF */

        } else if (config->options[i].name == "BGColour") {

            bg_colour = strtoul(config->options[i].value.c_str(), (char **)NULL, 0);

            bg_colour |= 0xFF000000L;  /* force alpha to 0xFF */

        }

    }

    if (wiringstring.length()) {

        optionstring = "WIRING=" + wiringstring + ((optionstring != "") ? ";" + optionstring : "");

    }

    if (controller == "")

    {

        syslog(LOG_ERR, "%s error: no controller given!\n", config->name.c_str());

        return -1;

    }

    if (config->device == "")

    {

        // use DirectIO

        // neither device nor port is set

        if (config->port == 0)

            return -1;

        char temp[10];

        snprintf(temp, 8, "0x%x", config->port);

        if (serdisp_version < SERDISP_VERSION(1,93) ) {

            sdcd = fp_PP_open(temp);

        } else {

            sdcd = fp_SDCONN_open(temp);

        }

        if (sdcd == 0) {

            syslog(LOG_ERR, "%s: error: unable to open port 0x%x for display %s. (cDriver::Init)\n",

                config->name.c_str(), config->port, controller.c_str());

            return -1;

        }

        uSleep(10);

    }

    else

    {

        // use ppdev

        if (serdisp_version < SERDISP_VERSION(1,93) ) {

            sdcd = fp_PP_open(config->device.c_str());

        } else {

            sdcd = fp_SDCONN_open(config->device.c_str());

        }

        if (sdcd == 0) {

            syslog(LOG_ERR, "%s: error: unable to open device %s for display %s. (cDriver::Init)\n",

                config->name.c_str(), config->device.c_str(), controller.c_str());

            return -1;

        }

    }

    if (serdisp_version < SERDISP_VERSION(1,95) )

        dd = fp_serdisp_init(sdcd, controller.c_str(), "");

    else

        dd = fp_serdisp_init(sdcd, controller.c_str(), optionstring.c_str());

    if (!dd)

    {

        syslog(LOG_ERR, "%s: error: cannot open display %s. Err:%s (cDriver::Init)\n",

            config->name.c_str(), controller.c_str(), "no handle");

        return -1;

    }

    width = config->width;

    if (width <= 0)

        width = fp_serdisp_getwidth(dd);

    height = config->height;

    if (height <= 0)

        height = fp_serdisp_getheight(dd);

    if (serdisp_version < SERDISP_VERSION(1,96) ) {

        fp_serdisp_feature(dd, FEATURE_ROTATE, config->upsideDown);

        fp_serdisp_feature(dd, FEATURE_CONTRAST, config->contrast);

        fp_serdisp_feature(dd, FEATURE_BACKLIGHT, config->backlight);

        fp_serdisp_feature(dd, FEATURE_REVERSE, config->invert);

    } else {

        /* standard options */

        fp_serdisp_setoption(dd, "ROTATE", config->upsideDown);

        fp_serdisp_setoption(dd, "CONTRAST", config->contrast);

        fp_serdisp_setoption(dd, "BACKLIGHT", config->backlight);

        fp_serdisp_setoption(dd, "INVERT", config->invert);

        /* driver dependend options */

        for (unsigned int i = 0; i < config->options.size(); i++) {

            std::string optionname = config->options[i].name;

            if (optionname != "UpsideDown" && optionname != "Contrast" &&

                optionname != "Backlight" && optionname != "Invert") {

                if ( fp_serdisp_isoption(dd, optionname.c_str()) == 1 )  /* if == 1: option is existing AND r/w */

                    fp_serdisp_setoption(dd, optionname.c_str(), strtol(config->options[i].value.c_str(), NULL, 0));

            }

        }

    }

    *oldConfig = *config;

    // clear display

    Clear();

    syslog(LOG_INFO, "%s: SerDisp with %s initialized.\n", config->name.c_str(), controller.c_str());

    return 0;

}

int cDriverSerDisp::DeInit(void)

{

    if (serdisp_version < SERDISP_VERSION(1,93) ) {

        fp_serdisp_close(dd);

        fp_PP_close(sdcd);

        sdcd = NULL;

    } else {

        //fp_serdisp_quit(dd);

        /* use serdisp_close instead of serdisp_quit so that showpic and showtext are usable together with serdisplib */

        fp_serdisp_close(dd);

    }

    (int) dlclose(sdhnd);

    sdhnd = NULL;

    return 0;

}

int cDriverSerDisp::CheckSetup()

{

    bool update = false;

    if (config->device != oldConfig->device ||

        config->port != oldConfig->port ||

        config->width != oldConfig->width ||

        config->height != oldConfig->height)

    {

        DeInit();

        Init();

        return 0;

    }

    if (config->contrast != oldConfig->contrast)

    {

        fp_serdisp_feature(dd, FEATURE_CONTRAST, config->contrast);

        oldConfig->contrast = config->contrast;

        update = true;

    }

    if (config->backlight != oldConfig->backlight)

    {

        fp_serdisp_feature(dd, FEATURE_BACKLIGHT, config->backlight);

        oldConfig->backlight = config->backlight;

        update = true;

    }

    if (config->upsideDown != oldConfig->upsideDown)

    {

        fp_serdisp_feature(dd, FEATURE_ROTATE, config->upsideDown);

        oldConfig->upsideDown = config->upsideDown;

        update = true;

    }

    if (config->invert != oldConfig->invert)

    {

        fp_serdisp_feature(dd, FEATURE_REVERSE, config->invert);

        oldConfig->invert = config->invert;

        update = true;

    }

    /* driver dependend options */

    for (unsigned int i = 0; i < config->options.size(); i++) {

        std::string optionname = config->options[i].name;

        if (optionname != "UpsideDown" && optionname != "Contrast" &&

            optionname != "Backlight" && optionname != "Invert") {

            if ( fp_serdisp_isoption(dd, optionname.c_str()) == 1 )  /* if == 1: option is existing AND r/w */

                fp_serdisp_setoption(dd, optionname.c_str(), strtol(config->options[i].value.c_str(), NULL, 0));

            oldConfig->options[i] = config->options[i];

            update = true;

        }

    }

    if (update)

        return 1;

    return 0;

}

void cDriverSerDisp::Clear(void)

{

    if (bg_colour == -1)

        fp_serdisp_clearbuffer(dd);

    else {  /* if bg_colour is set, draw background 'by hand' */

        int x,y;

        for (y = 0; y < fp_serdisp_getheight(dd); y++)

            for (x = 0; x < fp_serdisp_getwidth(dd); x++)

                fp_serdisp_setpixcol(dd, x, y, bg_colour);   /* >= 1.95: serdisp_setcolour(), < 1.95: serdisp_setpixel() */

    }

}

void cDriverSerDisp::Set8Pixels(int x, int y, unsigned char data) {

    int i, start, pixel;

    data = ReverseBits(data);

    start = (x >> 3) << 3;

    for (i = 0; i < 8; i++) {

        pixel = data & (1 << i);

        if (pixel)

            fp_serdisp_setpixcol(dd, start + i, y, fg_colour);   /* >= 1.95: serdisp_setcolour(), < 1.95: serdisp_setpixel() */

        else if (!pixel && bg_colour != -1)  /* if bg_colour is set: use it if pixel is not set */

            fp_serdisp_setpixcol(dd, start + i, y, bg_colour);   /* >= 1.95: serdisp_setcolour(), < 1.95: serdisp_setpixel() */

    }

}

void cDriverSerDisp::Refresh(bool refreshAll)

{

    if (CheckSetup() == 1)

        refreshAll = true;

    if (refreshAll)

        fp_serdisp_rewrite(dd);

    else

        fp_serdisp_update(dd);

}

} // end of namespace