/* $Id: fb.c,v 1.3 2002/07/18 15:10:52 ukai Exp $ */
/**************************************************************************
                fb.c 0.2 Copyright (C) 2002, hito
 **************************************************************************/

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

#include "fb.h"

#define FB_ENV		"FRAMEBUFFER"
#define	FB_DEFDEV	"/dev/fb0"

#define FALSE 0
#define TRUE  1

static struct fb_cmap *fb_cmap_create(struct fb_fix_screeninfo *,
				      struct fb_var_screeninfo *);
static void fb_cmap_destroy(struct fb_cmap *cmap);
static int fb_fscrn_get(int fbfp, struct fb_fix_screeninfo *scinfo);
static void *fb_mmap(int fbfp, struct fb_fix_screeninfo *scinfo);
static int fb_munmap(void *buf, struct fb_fix_screeninfo *scinfo);
static int fb_vscrn_get(int fbfp, struct fb_var_screeninfo *scinfo);

static struct fb_fix_screeninfo fscinfo;
static struct fb_var_screeninfo vscinfo;
static struct fb_cmap *cmap = NULL;
static int is_open = FALSE;
static int fbfp = -1;
static unsigned char *buf = NULL;

int
fb_open(void)
{
    char *fbdev = { FB_DEFDEV };

    if (is_open == TRUE)
	return 1;

    if (getenv(FB_ENV)) {
	fbdev = getenv(FB_ENV);
    }

    if ((fbfp = open(fbdev, O_RDWR)) == -1) {
	fprintf(stderr, "open %s error\n", fbdev);
	goto ERR_END;
    }

    if (fb_fscrn_get(fbfp, &fscinfo)) {
	goto ERR_END;
    }

    if (fb_vscrn_get(fbfp, &vscinfo)) {
	goto ERR_END;
    }

    if ((cmap = fb_cmap_create(&fscinfo, &vscinfo)) == (struct fb_cmap *)-1) {
	goto ERR_END;
    }

    if (!(buf = fb_mmap(fbfp, &fscinfo))) {
	fprintf(stderr, "Can't allocate memory.\n");
	goto ERR_END;
    }

    if (fscinfo.type != FB_TYPE_PACKED_PIXELS) {
	fprintf(stderr, "This type of framebuffer is not supported.\n");
	goto ERR_END;
    }

#if 0
    if (fscinfo.visual == FB_VISUAL_PSEUDOCOLOR) {
	printf("FB_VISUAL_PSEUDOCOLOR\n");
	if (vscinfo.bits_per_pixel != 8) {
	    fprintf(stderr, "未対応フレームバッファ\n");
	    goto ERR_END;
	}

	if (fb_cmap_get(fbfp, cmap)) {
	    fprintf(stderr, "カラーマップ獲得失敗\n");
	    //      fb_cmap_destroy(cmap);
	    goto ERR_END;
	}
	//    fb_cmap_disp(cmap);

	if (cmap->len < (LINUX_LOGO_COLORS + LOGO_COLOR_OFFSET)) {
	    fprintf(stderr, "色の割付領域が不足しています\n");
	    goto ERR_END;
	}

	cmap->start = LOGO_COLOR_OFFSET;
	cmap->len = LINUX_LOGO_COLORS;

	for (lp = 0; lp < LINUX_LOGO_COLORS; lp++) {
	    if (cmap->red) {
		*(cmap->red + lp) =
		    (linux_logo_red[lp] << CHAR_BIT) + linux_logo_red[lp];
	    }
	    if (cmap->green) {
		*(cmap->green + lp) =
		    (linux_logo_green[lp] << CHAR_BIT) + linux_logo_green[lp];
	    }
	    if (cmap->blue) {
		*(cmap->blue + lp) =
		    (linux_logo_blue[lp] << CHAR_BIT) + linux_logo_blue[lp];
	    }
	}
	if (fb_cmap_set(fbfp, cmap)) {
	    fb_cmap_destroy(cmap);
	    fprintf(stderr, "カラーマップ獲得失敗\n");
	    goto ERR_END;
	}
    }
#endif

    if (!(fscinfo.visual == FB_VISUAL_TRUECOLOR &&
	  (vscinfo.bits_per_pixel == 15 ||
	   vscinfo.bits_per_pixel == 16 ||
	   vscinfo.bits_per_pixel == 24 || vscinfo.bits_per_pixel == 32))) {
	fprintf(stderr, "This type of framebuffer is not supported.\n");
	goto ERR_END;
    }

    is_open = TRUE;
    return 0;

  ERR_END:
    fb_close();
    return 1;
}

void
fb_close(void)
{
    if (is_open != TRUE)
	return;

    if (cmap != NULL) {
	fb_cmap_destroy(cmap);
	cmap = NULL;
    }
    if (buf != NULL) {
	fb_munmap(buf, &fscinfo);
	buf = NULL;
    }

    if (fbfp >= 0) {
	close(fbfp);
    }

    is_open = FALSE;
}

void
fb_pset(int x, int y, int r, int g, int b)
{
    unsigned long work;
    int offset;
    static size_t size = 0;

    if (is_open != TRUE || x >= vscinfo.xres || y >= vscinfo.yres)
	return;

    if (size == 0)
	size = (vscinfo.bits_per_pixel + 7) / CHAR_BIT;

    offset = fscinfo.line_length * y + size * x;

    if (offset >= fscinfo.smem_len)
	return;

    work =
	((r >> (CHAR_BIT - vscinfo.red.length)) << vscinfo.red.offset) +
	((g >> (CHAR_BIT - vscinfo.green.length)) << vscinfo.green.offset) +
	((b >> (CHAR_BIT - vscinfo.blue.length)) << vscinfo.blue.offset);
    memcpy(buf + offset, &work, size);
}

int
fb_get_color(int x, int y, int *r, int *g, int *b)
{
    unsigned long work = 0;
    int offset;
    static size_t size = 0;

    if (is_open != TRUE || x >= vscinfo.xres || y >= vscinfo.yres)
	return 1;

    if (size == 0)
	size = (vscinfo.bits_per_pixel + 7) / CHAR_BIT;

    offset = fscinfo.line_length * y + size * x;
    if (offset >= fscinfo.smem_len)
	return 1;

    memcpy(&work, buf + offset, size);

    *r = ((work >> vscinfo.red.
	   offset) & (0x000000ff >> (CHAR_BIT - vscinfo.red.length)))
	<< (CHAR_BIT - vscinfo.red.length);
    *g = ((work >> vscinfo.green.
	   offset) & (0x000000ff >> (CHAR_BIT - vscinfo.green.length)))
	<< (CHAR_BIT - vscinfo.green.length);
    *b = ((work >> vscinfo.blue.
	   offset) & (0x000000ff >> (CHAR_BIT - vscinfo.blue.length)))
	<< (CHAR_BIT - vscinfo.blue.length);
    return 0;
}

void
fb_clear(void)
{
    if (is_open != TRUE)
	return;

    memset(buf, 0,
	   (vscinfo.xres * vscinfo.yres * vscinfo.bits_per_pixel) / CHAR_BIT);
}

int
fb_width(void)
{
    if (is_open != TRUE)
	return 0;

    return vscinfo.xres;
}

int
fb_height(void)
{
    if (is_open != TRUE)
	return 0;

    return vscinfo.yres;
}

void
fb_cmap_disp(void)
{
    int lp;

    if (is_open != TRUE)
	return;

    printf("cmap DUMP\n");
    printf("start		:[%08x]\n", cmap->start);
    printf("len		:[%08x]\n", cmap->len);
    printf("red		:[%8p]\n", cmap->red);
    if (cmap->red) {
	for (lp = 0; lp < cmap->len; lp++) {
	    if ((lp + 1) % 16 == 0)
		printf("%04x\n", *(cmap->red + lp));
	    else
		printf("%04x ", *(cmap->red + lp));
	}
	if (lp % 16)
	    printf("\n");
    }
    printf("green		:[%8p]\n", cmap->green);
    if (cmap->green) {
	for (lp = 0; lp < cmap->len; lp++) {
	    if ((lp + 1) % 16 == 0)
		printf("%04x\n", *(cmap->green + lp));
	    else
		printf("%04x ", *(cmap->green + lp));
	}
	if (lp % 16)
	    printf("\n");
    }
    printf("blue		:[%8p]\n", cmap->blue);
    if (cmap->blue) {
	for (lp = 0; lp < cmap->len; lp++) {
	    if ((lp + 1) % 16 == 0)
		printf("%04x\n", *(cmap->blue + lp));
	    else
		printf("%04x ", *(cmap->blue + lp));
	}
	if (lp % 16)
	    printf("\n");
    }
    printf("transp		:[%8p]\n", cmap->transp);
    if (cmap->transp) {
	for (lp = 0; lp < cmap->len; lp++) {
	    if ((lp + 1) % 16 == 0)
		printf("%04x\n", *(cmap->transp + lp));
	    else
		printf("%04x ", *(cmap->transp + lp));
	}
	if (lp % 16)
	    printf("\n");
    }
    return;
}


void
fb_fscrn_disp(void)
{
    if (is_open != TRUE)
	return;

    printf("scinfo[%8p] DUMP\n", &fscinfo);
    printf("id		:[%s]\n", fscinfo.id);
    printf("smem_start	:[%08lx]\n", fscinfo.smem_start);
    printf("smem_len	:[%d]\n", fscinfo.smem_len);
    printf("type		:[%d] ", fscinfo.type);
    switch (fscinfo.type) {
    case FB_TYPE_PACKED_PIXELS:
	printf("FB_TYPE_PACKED_PIXELS\n");
	break;
    case FB_TYPE_PLANES:
	printf("FB_TYPE_PLANES\n");
	break;
    case FB_TYPE_INTERLEAVED_PLANES:
	printf("FB_TYPE_INTERLEAVED_PLANES\n");
	break;
    case FB_TYPE_TEXT:
	printf("FB_TYPE_TEXT\n");
	break;
    default:
	printf("Unknown type.\n");
    }
    printf("type_aux	:[%d] ", fscinfo.type_aux);
    switch (fscinfo.type_aux) {
    case FB_AUX_TEXT_MDA:
	printf("FB_AUX_TEXT_MDA\n");
	break;
    case FB_AUX_TEXT_CGA:
	printf("FB_AUX_TEXT_CGA\n");
	break;
    case FB_AUX_TEXT_S3_MMIO:
	printf("FB_AUX_TEXT_S3_MMIO\n");
	break;
    case FB_AUX_TEXT_MGA_STEP16:
	printf("FB_AUX_TEXT_MGA_STEP16\n");
	break;
    case FB_AUX_TEXT_MGA_STEP8:
	printf("FB_AUX_TEXT_MGA_STEP8\n");
	break;
    default:
	printf("Unknown type_aux.\n");
    }
    printf("visual		:[%d] ", fscinfo.visual);
    switch (fscinfo.visual) {
    case FB_VISUAL_MONO01:
	printf("FB_VISUAL_MONO01\n");
	break;
    case FB_VISUAL_MONO10:
	printf("FB_VISUAL_MONO10\n");
	break;
    case FB_VISUAL_TRUECOLOR:
	printf("FB_VISUAL_TRUECOLOR\n");
	break;
    case FB_VISUAL_PSEUDOCOLOR:
	printf("FB_VISUAL_PSEUDOCOLOR\n");
	break;
    case FB_VISUAL_DIRECTCOLOR:
	printf("FB_VISUAL_DIRECTCOLOR\n");
	break;
    case FB_VISUAL_STATIC_PSEUDOCOLOR:
	printf("FB_VISUAL_STATIC_PSEUDOCOLOR\n");
	break;
    default:
	printf("Unknown Visual mode.\n");
    }
    printf("xpanstep	:[%d]\n", fscinfo.xpanstep);
    printf("ypanstep	:[%d]\n", fscinfo.ypanstep);
    printf("ywrapstep	:[%d]\n", fscinfo.ywrapstep);
    printf("line_length	:[%d]\n", fscinfo.line_length);
    printf("mmio_start	:[%08lx]\n", fscinfo.mmio_start);
    printf("mmio_len	:[%d]\n", fscinfo.mmio_len);
    printf("accel		:[%d] ", fscinfo.accel);
    switch (fscinfo.accel) {
    case FB_ACCEL_NONE:
	printf("FB_ACCEL_NONE\n");
	break;
    case FB_ACCEL_ATARIBLITT:
	printf("FB_ACCEL_ATARIBLITT\n");
	break;
    case FB_ACCEL_AMIGABLITT:
	printf("FB_ACCEL_AMIGABLITT\n");
	break;
    case FB_ACCEL_S3_TRIO64:
	printf("FB_ACCEL_S3_TRIO64\n");
	break;
    case FB_ACCEL_NCR_77C32BLT:
	printf("FB_ACCEL_NCR_77C32BLT\n");
	break;
    case FB_ACCEL_S3_VIRGE:
	printf("FB_ACCEL_S3_VIRGE\n");
	break;
    case FB_ACCEL_ATI_MACH64GX:
	printf("FB_ACCEL_ATI_MACH64GX\n");
	break;
    case FB_ACCEL_DEC_TGA:
	printf("FB_ACCEL_DEC_TGA\n");
	break;
    case FB_ACCEL_ATI_MACH64CT:
	printf("FB_ACCEL_ATI_MACH64CT\n");
	break;
    case FB_ACCEL_ATI_MACH64VT:
	printf("FB_ACCEL_ATI_MACH64VT\n");
	break;
    case FB_ACCEL_ATI_MACH64GT:
	printf("FB_ACCEL_ATI_MACH64GT\n");
	break;
    case FB_ACCEL_SUN_CREATOR:
	printf("FB_ACCEL_SUN_CREATOR\n");
	break;
    case FB_ACCEL_SUN_CGSIX:
	printf("FB_ACCEL_SUN_CGSIX\n");
	break;
    case FB_ACCEL_SUN_LEO:
	printf("FB_ACCEL_SUN_LEO\n");
	break;
    case FB_ACCEL_IMS_TWINTURBO:
	printf("FB_ACCEL_IMS_TWINTURBO\n");
	break;
    case FB_ACCEL_3DLABS_PERMEDIA2:
	printf("FB_ACCEL_3DLABS_PERMEDIA2\n");
	break;
    case FB_ACCEL_MATROX_MGA2064W:
	printf("FB_ACCEL_MATROX_MGA2064W\n");
	break;
    case FB_ACCEL_MATROX_MGA1064SG:
	printf("FB_ACCEL_MATROX_MGA1064SG\n");
	break;
    case FB_ACCEL_MATROX_MGA2164W:
	printf("FB_ACCEL_MATROX_MGA2164W\n");
	break;
    case FB_ACCEL_MATROX_MGA2164W_AGP:
	printf("FB_ACCEL_MATROX_MGA2164W_AGP\n");
	break;
    case FB_ACCEL_MATROX_MGAG100:
	printf("FB_ACCEL_MATROX_MGAG100\n");
	break;
    case FB_ACCEL_MATROX_MGAG200:
	printf("FB_ACCEL_MATROX_MGAG200\n");
	break;
    case FB_ACCEL_SUN_CG14:
	printf("FB_ACCEL_SUN_CG14\n");
	break;
    case FB_ACCEL_SUN_BWTWO:
	printf("FB_ACCEL_SUN_BWTWO\n");
	break;
    case FB_ACCEL_SUN_CGTHREE:
	printf("FB_ACCEL_SUN_CGTHREE\n");
	break;
    case FB_ACCEL_SUN_TCX:
	printf("FB_ACCEL_SUN_TCX\n");
	break;
    default:
	printf("Unknown Visual mode.\n");
    }
    return;
}

void
fb_vscrn_disp(void)
{
    if (is_open != TRUE)
	return;
    printf("vscinfo DUMP\n");
    printf("xres		:[%d]\n", vscinfo.xres);
    printf("yres		:[%d]\n", vscinfo.yres);
    printf("xres_virtual	:[%d]\n", vscinfo.xres_virtual);
    printf("yres_virtual	:[%d]\n", vscinfo.yres_virtual);
    printf("xoffset		:[%d]\n", vscinfo.xoffset);
    printf("yoffset		:[%d]\n", vscinfo.yoffset);
    printf("bits_per_pixel	:[%d]\n", vscinfo.bits_per_pixel);
    printf("grayscale	:[%d]\n", vscinfo.grayscale);
    printf("red.offset	:[%d]\n", vscinfo.red.offset);
    printf("red.length	:[%d]\n", vscinfo.red.length);
    printf("red.msb_right	:[%d]\n", vscinfo.red.msb_right);
    printf("green.offset	:[%d]\n", vscinfo.green.offset);
    printf("green.length	:[%d]\n", vscinfo.green.length);
    printf("green.msb_right	:[%d]\n", vscinfo.green.msb_right);
    printf("blue.offset	:[%d]\n", vscinfo.blue.offset);
    printf("blue.length	:[%d]\n", vscinfo.blue.length);
    printf("blue.msb_right	:[%d]\n", vscinfo.blue.msb_right);
    printf("transp.offset	:[%d]\n", vscinfo.transp.offset);
    printf("transp.length	:[%d]\n", vscinfo.transp.length);
    printf("transp.msb_right:[%d]\n", vscinfo.transp.msb_right);
    printf("nonstd		:[%d]\n", vscinfo.nonstd);
    printf("activate	:[%d]\n", vscinfo.activate);
    printf("height		:[%d]\n", vscinfo.height);
    printf("width		:[%d]\n", vscinfo.width);
    printf("accel_flags	:[%d]\n", vscinfo.accel_flags);
    printf("pixclock	:[%d]\n", vscinfo.pixclock);
    printf("left_margin	:[%d]\n", vscinfo.left_margin);
    printf("right_margin	:[%d]\n", vscinfo.right_margin);
    printf("upper_margin	:[%d]\n", vscinfo.upper_margin);
    printf("lower_margin	:[%d]\n", vscinfo.lower_margin);
    printf("hsync_len	:[%d]\n", vscinfo.hsync_len);
    printf("vsync_len	:[%d]\n", vscinfo.vsync_len);
    printf("sync		:[%d]\n", vscinfo.sync);
    printf("vmode		:[%d]\n", vscinfo.vmode);
    return;
}

/********* static functions **************/

/*
 * (struct fb_cmap)デバイスに依存しないカラーマップ情報
 * 
 * fb_cmap_create()     新規のカラーマップ情報
 * fb_cmap_destroy()    カラーマップ情報の破棄
 * fb_cmap_disp()               情報の表示
 * fb_cmap_get()                情報の獲得
 * fb_cmap_set()                情報の設定
 */

#define	LUT_MAX		(256)

static struct fb_cmap *
fb_cmap_create(struct fb_fix_screeninfo *fscinfo,
	       struct fb_var_screeninfo *vscinfo)
{
    struct fb_cmap *cmap;
    int cmaplen = LUT_MAX;

    /* カラーマップの存在チェック */
    if (fscinfo->visual == FB_VISUAL_MONO01 ||
	fscinfo->visual == FB_VISUAL_MONO10 ||
	fscinfo->visual == FB_VISUAL_TRUECOLOR)
	return NULL;

    cmap = (struct fb_cmap *)malloc(sizeof(struct fb_cmap));
    if (!cmap) {
	perror("cmap malloc error\n");
	return (struct fb_cmap *)-1;
    }
    memset(cmap, 0, sizeof(struct fb_cmap));

    /* 各分色が存在しそうだったらカラーマップ用の領域を確保 */
    if (vscinfo->red.length) {
	cmap->red = (__u16 *) malloc(sizeof(__u16) * cmaplen);
	if (!cmap->red) {
	    perror("red lut malloc error\n");
	    return (struct fb_cmap *)-1;
	}
    }
    if (vscinfo->green.length) {
	cmap->green = (__u16 *) malloc(sizeof(__u16) * cmaplen);
	if (!cmap->green) {
	    if (vscinfo->red.length)
		free(cmap->red);
	    perror("green lut malloc error\n");
	    return (struct fb_cmap *)-1;
	}
    }
    if (vscinfo->blue.length) {
	cmap->blue = (__u16 *) malloc(sizeof(__u16) * cmaplen);
	if (!cmap->blue) {
	    if (vscinfo->red.length)
		free(cmap->red);
	    if (vscinfo->green.length)
		free(cmap->green);
	    perror("blue lut malloc error\n");
	    return (struct fb_cmap *)-1;
	}
    }
    if (vscinfo->transp.length) {
	cmap->transp = (__u16 *) malloc(sizeof(__u16) * cmaplen);
	if (!cmap->transp) {
	    if (vscinfo->red.length)
		free(cmap->red);
	    if (vscinfo->green.length)
		free(cmap->green);
	    if (vscinfo->blue.length)
		free(cmap->blue);
	    perror("transp lut malloc error\n");
	    return (struct fb_cmap *)-1;
	}
    }
    cmap->len = cmaplen;
    return cmap;
}

static void
fb_cmap_destroy(struct fb_cmap *cmap)
{
    if (cmap->red)
	free(cmap->red);
    if (cmap->green)
	free(cmap->green);
    if (cmap->blue)
	free(cmap->blue);
    if (cmap->transp)
	free(cmap->transp);
    free(cmap);
}

#if 0
static int
fb_cmap_get(int fbfp, struct fb_cmap *cmap)
{
    if (ioctl(fbfp, FBIOGETCMAP, cmap)) {
	perror("ioctl FBIOGETCMAP error\n");
	return -1;
    }
    return 0;
}

static int
fb_cmap_set(int fbfp, struct fb_cmap *cmap)
{
    if (ioctl(fbfp, FBIOPUTCMAP, cmap)) {
	perror("ioctl FBIOPUTCMAP error\n");
	return -1;
    }
    return 0;
}
#endif
/*
 * フレームバッファに対するアクセス
 * 
 * fb_mmap()            フレームバッファのメモリ上へのマップ
 * fb_munmap()          フレームバッファのメモリ上からのアンマップ
 */

static void *
fb_mmap(int fbfp, struct fb_fix_screeninfo *scinfo)
{
    void *buf;
    if ((buf = (unsigned char *)
	 mmap(NULL, scinfo->smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fbfp,
	      (off_t) 0))
	== MAP_FAILED) {
	perror("mmap error");
	return NULL;
    }
    return buf;
}

static int
fb_munmap(void *buf, struct fb_fix_screeninfo *scinfo)
{
    return munmap(buf, scinfo->smem_len);
}

/*
 * (struct fb_fix_screeninfo)デバイスに依存しない固定された情報
 * 
 * fb_fscrn_disp()              情報の表示
 * fb_fscrn_get()               情報の獲得
 */
static int
fb_fscrn_get(int fbfp, struct fb_fix_screeninfo *scinfo)
{
    if (ioctl(fbfp, FBIOGET_FSCREENINFO, scinfo)) {
	perror("ioctl FBIOGET_FSCREENINFO error\n");
	return -1;
    }
    return 0;
}

/*
 * (struct fb_var_screeninfo)デバイスに依存しない変更可能な情報
 * 
 * fb_vscrn_disp()              情報の表示
 * fb_vscrn_get()               情報の獲得
 * fb_vscrn_set()               情報の設定
 */
static int
fb_vscrn_get(int fbfp, struct fb_var_screeninfo *scinfo)
{
    if (ioctl(fbfp, FBIOGET_VSCREENINFO, scinfo)) {
	perror("ioctl FBIOGET_VSCREENINFO error\n");
	return -1;
    }
    return 0;
}

#if 0
static int
fb_vscrn_set(int fbfp, struct fb_var_screeninfo *scinfo)
{
    if (ioctl(fbfp, FBIOPUT_VSCREENINFO, scinfo)) {
	perror("ioctl FBIOPUT_VSCREENINFO error\n");
	return -1;
    }
    return 0;
}
#endif