drv_TEW673GRU.c

/* $Id$
 * $URL$
 *
 * TRENDnet TEW673GRU LCD4linux driver
 *
 * Copyright (C) 2012 Gabor Juhos <juhosg@openwrt.org>
 *
 * based on the Sample driver which is:
 * Copyright (C) 2005 Michael Reinelt <michael@reinelt.co.at>
 * Copyright (C) 2005, 2006, 2007 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
 *
 * This file is part of LCD4Linux.
 *
 * LCD4Linux 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, or (at your option)
 * any later version.
 *
 * LCD4Linux 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, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/*
 * exported fuctions:
 *
 * struct DRIVER drv_TEW673GRU
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#include "debug.h"
#include "cfg.h"
#include "qprintf.h"
#include "udelay.h"
#include "plugin.h"
#include "widget.h"
#include "widget_text.h"
#include "widget_icon.h"
#include "widget_bar.h"
#include "drv.h"

#include "drv_generic_text.h"
#include "drv_generic_graphic.h"
#include "drv_generic_spidev.h"

#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif

#define TEW673GRU_NUM_COLS	220
#define TEW673GRU_NUM_ROWS	176
#define TEW673GRU_BPP		2       /* bytes per pixel */

#define TEW673GRU_CMD_SIZE	9
#define TEW673GRU_NUM_ROW_BYTES (TEW673GRU_NUM_COLS * TEW673GRU_BPP)

enum {
    CMD_SHOW_STRING = 49,
    CMD_SHOW_IMAGE_DIR = 52,
    CMD_SCREEN_COLOR = 54,
};

static char Name[] = "TEW673GRU";

static char *drv_TEW673GRU_FB;
static long FB_SIZE;
static int MODE;

static unsigned int RGBAto16(RGBA rgb)
{
    return (((rgb.R >> 3) << 11) | ((rgb.G >> 2) << 5) | (rgb.B >> 3));
}

static unsigned char color_msb(unsigned int color)
{
    return color >> 8;
}

static unsigned char color_lsb(unsigned int color)
{
    return color & 0xff;
}

static void drv_TEW673GRU_hw_clear(const unsigned int color)
{
    unsigned char cmd[TEW673GRU_CMD_SIZE];
    struct spi_ioc_transfer tr[1];

    memset(tr, '\0', sizeof(tr));
    memset(cmd, '\0', sizeof(cmd));

    cmd[0] = CMD_SCREEN_COLOR;
    cmd[7] = color_msb(color);
    cmd[8] = color_lsb(color);

    tr[0].tx_buf = (unsigned long) cmd;
    tr[0].len = sizeof(cmd);

    drv_generic_spidev_transfer(1, tr);
}

static void drv_TEW673GRU_hw_send_row(const int row, const int col, const char *data, const int width)
{
    unsigned char cmd[TEW673GRU_CMD_SIZE];
    struct spi_ioc_transfer tr[2];
    int datasize;

    memset(tr, '\0', sizeof(tr));
    memset(cmd, '\0', sizeof(cmd));

    datasize = width * TEW673GRU_BPP;

    cmd[0] = CMD_SHOW_IMAGE_DIR;
    cmd[1] = col;
    cmd[2] = col + width;
    cmd[3] = row;
    cmd[4] = row;
    cmd[5] = datasize >> 8;
    cmd[6] = datasize & 0xff;

    tr[0].tx_buf = (unsigned long) cmd;
    tr[0].len = sizeof(cmd);
    tr[1].tx_buf = (unsigned long) data;
    tr[1].len = datasize;

    drv_generic_spidev_transfer(2, tr);
}

static void drv_TEW673GRU_hw_write_string(const int row, const int col, const char *data, const int datasize)
{
    unsigned char cmd[TEW673GRU_CMD_SIZE];
    struct spi_ioc_transfer tr[2];
    unsigned char len;

    memset(tr, '\0', sizeof(tr));
    memset(cmd, '\0', sizeof(cmd));

    len = datasize & 0xff;
    cmd[0] = CMD_SHOW_STRING;
    cmd[1] = col;
    cmd[2] = col + (XRES * len);
    cmd[3] = row;
    cmd[4] = row + YRES;
    cmd[7] = 0;
    cmd[8] = len;

    tr[0].tx_buf = (unsigned long) cmd;
    tr[0].len = sizeof(cmd);
    tr[1].tx_buf = (unsigned long) data;
    tr[1].len = datasize;

    drv_generic_spidev_transfer(2, tr);
}

static void drv_TEW673GRU_FB_set_pixel(const int col, const unsigned int color)
{
    int pos;

    pos = col * TEW673GRU_BPP;
    drv_TEW673GRU_FB[pos] = color_msb(color);
    drv_TEW673GRU_FB[pos + 1] = color_lsb(color);
}

static void drv_TEW673GRU_blit(const int row, const int col, const int height, const int width)
{
    int r, c;

    debug("%s: update area r:%d c:%d w:%d h:%d", Name, row, col, height, width);

    for (r = row; r < row + height; r++) {
        for (c = col; c < col + width; c++) {
            unsigned int color;
            RGBA rgb;

            rgb = drv_generic_graphic_rgb(r, c);
            color = RGBAto16(rgb);
            drv_TEW673GRU_FB_set_pixel(c, color);
        }

        if (width) {
            char *data;

            data = &drv_TEW673GRU_FB[col * TEW673GRU_BPP];
            drv_TEW673GRU_hw_send_row(r, col, data, width);
            udelay(100 + width * 50);
        }
    }
}

static void drv_TEW673GRU_clear(RGBA rgba)
{
    unsigned int color;

    color = RGBAto16(rgba);
    drv_TEW673GRU_hw_clear(color);
}

static void drv_TEW673GRU_write(const int row, const int col, const char *data, const int len)
{
    int i;

    for (i = 0; i < len; i++) {
        drv_TEW673GRU_hw_write_string(row * YRES, (col + i) * XRES, " ", 1);
        udelay(10000);
        drv_TEW673GRU_hw_write_string(row * YRES, 2 + (col + i) * XRES, " ", 1);
        udelay(10000);
        drv_TEW673GRU_hw_write_string(row * YRES, (col + i) * XRES, &data[i], 1);
        udelay(10000);
    }
}

static int drv_TEW673GRU_open(const char *section)
{
    int err;

    err = drv_generic_spidev_open(section, Name);
    if (err < 0)
        return err;

    return 0;
}

static int drv_TEW673GRU_close(void)
{
    drv_generic_spidev_close();
    return 0;
}

static void drv_TEW673GRU_clear_screen(void)
{
    if (MODE) {
        drv_generic_graphic_clear();
    } else {
        memset(drv_TEW673GRU_FB, ' ', FB_SIZE);
        drv_TEW673GRU_hw_clear(0x0000);
    }
}

static int drv_TEW673GRU_init_font(const char *section)
{
    char *font;
    int ret = -1;

    font = cfg_get(section, "Font", "6x8");
    if (font == NULL) {
        error("%s: no '%s.Font' entry from %s", Name, section, cfg_source());
        goto out;
    }

    if (*font == '\0') {
        error("%s: invalid '%s.Font' entry in %s", Name, section, cfg_source());
        goto out_free;
    }

    XRES = -1;
    YRES = -1;
    if (sscanf(font, "%dx%d", &XRES, &YRES) != 2 || XRES < 1 || YRES < 1) {
        error("%s: bad Font '%s' from %s", Name, font, cfg_source());
        goto out_free;
    }

    if (XRES != 6 && YRES != 8) {
        error("%s: bad Font '%s' from %s (only 6x8 at the moment)", Name, font, cfg_source());
        goto out_free;
    }

    error("%s: font '%s' selected", Name, font);

    ret = 0;

  out_free:
    free(font);
  out:
    return ret;
}

static int drv_TEW673GRU_start(const char *section)
{
    int ret;

    DCOLS = TEW673GRU_NUM_COLS;
    DROWS = TEW673GRU_NUM_ROWS;

    if (MODE) {
        ret = drv_TEW673GRU_init_font(section);
        if (ret)
            goto err;

        FB_SIZE = DCOLS * TEW673GRU_BPP;
    } else {
        XRES = 10;
        YRES = 16;
        DCOLS = DCOLS / XRES;
        DROWS = DROWS / YRES;

        FB_SIZE = DCOLS * DROWS;
    }

    if (FB_SIZE) {
        drv_TEW673GRU_FB = malloc(FB_SIZE);
        if (drv_TEW673GRU_FB == NULL) {
            error("%s: framebuffer could not be allocated", Name);
            goto err;
        }
    }

    ret = drv_TEW673GRU_open(section);
    if (ret < 0)
        goto err_free;

    if (MODE == 0)
        drv_TEW673GRU_clear_screen();

    return 0;

  err_free:
    if (drv_TEW673GRU_FB)
        free(drv_TEW673GRU_FB);
  err:
    return -1;
}

static int drv_TEW673GRU_greet(const char *msg1, const char *msg2)
{
    if (MODE)
        return drv_generic_graphic_greet(msg1, msg2);

    return drv_generic_text_greet(msg1, msg2);
}


/****************************************/
/***        widget callbacks          ***/
/****************************************/


/* using drv_generic_text_draw(W) */
/* using drv_generic_text_icon_draw(W) */
/* using drv_generic_text_bar_draw(W) */
/* using drv_generic_gpio_draw(W) */


/****************************************/
/***        exported functions        ***/
/****************************************/

int drv_TEW673GRU_list(void)
{
    printf("TEW673GRU driver");
    return 0;
}

int drv_TEW673GRU_init(const char *section, const int quiet)
{
    WIDGET_CLASS wc;
    int ret;

    cfg_number(section, "Mode", 0, 0, 1, &MODE);

    if (MODE) {
        drv_generic_graphic_real_blit = drv_TEW673GRU_blit;
        drv_generic_graphic_real_clear = drv_TEW673GRU_clear;
    } else {
        drv_generic_text_real_write = drv_TEW673GRU_write;
    }

    ret = drv_TEW673GRU_start(section);
    if (ret)
        return ret;

    if (MODE) {
        ret = drv_generic_graphic_init(section, Name);
        if (ret)
            return ret;
    } else {
        ret = drv_generic_text_init(section, Name);
        if (ret)
            return ret;

        ret = drv_generic_text_icon_init();
        if (ret != 0)
            return ret;

        ret = drv_generic_text_bar_init(1);
        if (ret != 0)
            return ret;

        drv_generic_text_bar_add_segment(0, 0, 255, ' ');
        drv_generic_text_bar_add_segment(255, 255, 255, '#');

        wc = Widget_Text;
        wc.draw = drv_generic_text_draw;
        widget_register(&wc);

        wc = Widget_Icon;
        wc.draw = drv_generic_text_icon_draw;
        widget_register(&wc);

        wc = Widget_Bar;
        wc.draw = drv_generic_text_bar_draw;
        widget_register(&wc);
    }

    if (!quiet) {
        char buffer[40];
        qprintf(buffer, sizeof(buffer), "%s %dx%d", Name, DCOLS, DROWS);
        drv_TEW673GRU_greet(buffer, "www.openwrt.org");
        sleep(3);
        drv_TEW673GRU_clear_screen();
    }

    return 0;
}

int drv_TEW673GRU_quit(const int quiet)
{

    info("%s: shutting down.", Name);

    drv_TEW673GRU_clear_screen();

    if (!quiet)
        drv_TEW673GRU_greet("goodbye!", NULL);

    if (MODE)
        drv_generic_graphic_quit();
    else
        drv_generic_text_quit();

    debug("closing connection");
    drv_TEW673GRU_close();

    return (0);
}

DRIVER drv_TEW673GRU = {
    .name = Name,
    .list = drv_TEW673GRU_list,
    .init = drv_TEW673GRU_init,
    .quit = drv_TEW673GRU_quit,
};