/*

 * GraphLCD driver library

 *

 * hd61830.c  -  HD61830 driver class

 *

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

 * to the COPYING file distributed with this package.

 *

 * (c) 2001-2004 Carsten Siebholz <c.siebholz AT t-online.de>

 */

#include <syslog.h>

#include <sys/time.h>

#include "common.h"

#include "config.h"

#include "hd61830.h"

#include "port.h"

namespace GLCD

{

// commands

#define MCNT    0x00

#define CPIT    0x01

#define NOCH    0x02

#define NOTD    0x03

#define CPOS    0x04

#define DSAL    0x08

#define DSAH    0x09

#define CACL    0x0A

#define CACH    0x0B

#define WDDI    0x0C

#define RDDI    0x0D

#define CBIT    0x0E

#define SBIT    0x0F

// control bits for DirectIO

#define EN      0x01

#define ENHI    0x00

#define ENLO    0x01

#define RW      0x02

#define RWHI    0x00

#define RWLO    0x02

#define RS      0x04

#define RSHI    0x04

#define RSLO    0x00

cDriverHD61830::cDriverHD61830(cDriverConfig * config)

:   config(config)

{

    oldConfig = new cDriverConfig(*config);

    port = new cParallelPort();

    useSleepInit = false;

    refreshCounter = 0;

    timeForPortCmdInNs = 0;

}

cDriverHD61830::~cDriverHD61830()

{

    delete port;

    delete oldConfig;

}

int cDriverHD61830::Init()

{

    int i;

    int x;

    struct timeval tv1, tv2;

    width = config->width;

    if (width <= 0)

        width = 240;

    height = config->height;

    if (height <= 0)

        height = 128;

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

    {

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

        {

        }

    }

    // setup lcd array (wanted state)

    newLCD = new unsigned char *[(width + 7) / 8];

    if (newLCD)

    {

        for (x = 0; x < (width + 7) / 8; x++)

        {

            newLCD[x] = new unsigned char[height];

            memset(newLCD[x], 0, height);

        }

    }

    // setup lcd array (current state)

    oldLCD = new unsigned char*[(width + 7) / 8];

    if (oldLCD)

    {

        for (x = 0; x < (width + 7) / 8; x++)

        {

            oldLCD[x] = new unsigned char[height];

            memset(oldLCD[x], 0, height);

        }

    }

    if (config->device == "")

    {

        // use DirectIO

        if (port->Open(config->port) != 0)

            return -1;

        uSleep(10);

    }

    else

    {

        // use ppdev

        if (port->Open(config->device.c_str()) != 0)

            return -1;

    }

    if (nSleepInit() != 0)

    {

        syslog(LOG_DEBUG, "%s: INFO: cannot change wait parameters (cDriver::Init)\n", config->name.c_str());

        useSleepInit = false;

    }

    else

    {

        useSleepInit = true;

    }

    syslog(LOG_DEBUG, "%s: benchmark started.\n", config->name.c_str());

    gettimeofday(&tv1, 0);

    for (i = 0; i < 1000; i++)

    {

        port->WriteData(1 % 0x100);

    }

    gettimeofday(&tv2, 0);

    if (useSleepInit)

        nSleepDeInit();

    timeForPortCmdInNs = (tv2.tv_sec-tv1.tv_sec) * 1000000 + (tv2.tv_usec-tv1.tv_usec);

    syslog(LOG_DEBUG, "%s: benchmark stopped. Time for Port Command: %ldns\n", config->name.c_str(), timeForPortCmdInNs);

    // initialize graphic mode

    InitGraphic();

    port->Release();

    *oldConfig = *config;

    // clear display

    Clear();

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

    return 0;

}

int cDriverHD61830::DeInit()

{

    int x;

    // free lcd array (wanted state)

    if (newLCD)

    {

        for (x = 0; x < (width + 7) / 8; x++)

        {

            delete[] newLCD[x];

        }

        delete[] newLCD;

    }

    // free lcd array (current state)

    if (oldLCD)

    {

        for (x = 0; x < (width + 7) / 8; x++)

        {

            delete[] oldLCD[x];

        }

        delete[] oldLCD;

    }

    if (port->Close() != 0)

        return -1;

    return 0;

}

int cDriverHD61830::CheckSetup()

{

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

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

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

        config->height != oldConfig->height)

    {

        DeInit();

        Init();

        return 0;

    }

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

        config->invert != oldConfig->invert)

    {

        oldConfig->upsideDown = config->upsideDown;

        oldConfig->invert = config->invert;

        return 1;

    }

    return 0;

}

int cDriverHD61830::InitGraphic()

{

    Write(MCNT, 0x32); // set Mode Control Register

    // DISP ON, MASTER ON, BLINK OFF, CURSOR OFF, GRAPHIC-Mode, int.Clock

    Write(CPIT, 0x07); // set Character Pitch Register

    // 8 pixels per byte

    Write(NOCH, std::max(1, (width + 7) / 8 - 1)); // set Number-Of-Characters Register

    // (width - 1) / 8 bytes per line horizontally

    Write(NOTD, std::max(1, height - 1)); // set Number-Of-Time-Divisions Register

    // height - 1

    Write(CPOS, 0x00); // set Cursor Position Register

    // optional, because we havn't enabled a cursor

    Write(DSAL, 0x00); // set Display Start Address Register (Low Order Byte)

    Write(DSAH, 0x00); // set Display Start Address Register (High Order Byte)

    Write(CACL, 0x00); // set Cursor Address Counter Register (Low Order Byte)

    Write(CACH, 0x00); // set Cursor Address Counter Register (High Order Byte)

    return 0;

}

void cDriverHD61830::Write(unsigned char cmd, unsigned char data)

{

    if (useSleepInit)

        nSleepInit();

    // set RS high (instruction), RW low (write) and E low

    port->WriteControl(RSHI | RWLO | ENLO);

    nSleep(140 - timeForPortCmdInNs + 100 * config->adjustTiming);

    // Output the actual command

    port->WriteData(cmd);

    // set E high

    port->WriteControl(RSHI | RWLO | ENHI);

    nSleep(450 - timeForPortCmdInNs + 100 * config->adjustTiming);

    // set E low

    port->WriteControl(RSHI | RWLO | ENLO);

    nSleep(450 - timeForPortCmdInNs + 100 * config->adjustTiming);

    // set RS low (data), RW low (write) and E low

    port->WriteControl(RSLO | RWLO | ENLO);

    nSleep(140 - timeForPortCmdInNs + 100 * config->adjustTiming);

    // Output the actual data

    port->WriteData(data);

    // set E high

    port->WriteControl(RSLO | RWLO | ENHI);

    nSleep(450 - timeForPortCmdInNs + 100 * config->adjustTiming);

    // set E low

    port->WriteControl(RSLO | RWLO | ENLO);

    nSleep(450 - timeForPortCmdInNs + 100 * config->adjustTiming);

    switch (cmd)

    {

        case MCNT:

        case CPIT:

        case NOCH:

        case NOTD:

        case CPOS:

        case DSAL:

        case DSAH:

        case CACL:

        case CACH:

            nSleep(4000 - std::max(450l, timeForPortCmdInNs) + 100 * config->adjustTiming);

            break;

        case WDDI:

        case RDDI:

            nSleep(6000 - std::max(450l, timeForPortCmdInNs) + 100 * config->adjustTiming);

            break;

        case CBIT:

        case SBIT:

            nSleep(36000 - std::max(450l, timeForPortCmdInNs) + 100 * config->adjustTiming);

            break;

    }

    if (useSleepInit)

        nSleepDeInit();

}

void cDriverHD61830::Clear()

{

    for (int x = 0; x < (width + 7) / 8; x++)

        memset(newLCD[x], 0, height);

}

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

{

    if (x >= width || y >= height)

        return;

    if (!config->upsideDown)

    {

        // normal orientation

        newLCD[x / 8][y] = newLCD[x / 8][y] | ReverseBits(data);

    }

    else

    {

        // upside down orientation

        x = width - 1 - x;

        y = height - 1 - y;

        newLCD[x / 8][y] = newLCD[x / 8][y] | data;

    }

}

void cDriverHD61830::Refresh(bool refreshAll)

{

    int x;

    int y;

    int pos = 0;

    if (CheckSetup() > 0)

        refreshAll = true;

    if (config->refreshDisplay > 0)

    {

        refreshCounter = (refreshCounter + 1) % config->refreshDisplay;

        if (!refreshAll && !refreshCounter)

            refreshAll = true;

    }

    port->Claim();

    if (refreshAll)

    {

        // draw all

        for (y = 0; y < height; y++)

        {

            for (x = 0; x < (width + 7) / 8; x++)

            {

                // (re-setting the cursor position

                //  might be removed, when the graphic glitches are solved)

                Write(CACL, (pos % 0x100));

                Write(CACH, (pos / 0x100));

                Write(WDDI, (newLCD[x][y]) ^ (config->invert ? 0xff : 0x00));

                oldLCD[x][y] = newLCD[x][y];

                pos++;

            }

        }

        // and reset RefreshCounter

        refreshCounter = 0;

    }

    else

    {

        // draw only the changed bytes

        bool cs = false;

        for (y = 0; y < height; y++)

        {

            for (x = 0; x < (width + 7) / 8; x++)

            {

                if (newLCD[x][y] != oldLCD[x][y])

                {

                    if (!cs)

                    {

                        Write(CACL, (pos % 0x100));

                        Write(CACH, (pos / 0x100));

                        cs = true;

                    }

                    Write(WDDI, (newLCD[x][y]) ^ (config->invert ? 0xff : 0x00));

                    oldLCD[x][y] = newLCD[x][y];

                }

                else

                {

                    cs = false;

                }

                pos++;

            }

        }

    }

    port->Release();

}

} // end of namespace