drv_SamsungSPF.c

/* $Id: drv_SamsungSPF 975 2009-01-18 11:16:20Z michael $
   * $URL: https://ssl.bulix.org/svn/lcd4linux/trunk/drv_SamsungSPF.c $
   *
   * SamsungSPF lcd4linux driver
   *
   * Copyright (C) 2012 Sascha Plazar <sascha@plazar.de>
   * Copyright (C) 2005, 2006, 2007 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
   *
   * This driver is based on playusb.c created on Aug 2, 2010 by Andre Puschmann
   * which is in turn based on code from Grace Woo:
   *    http://web.media.mit.edu/~gracewoo/stuff/picframe
   *
   * 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_SamsungSPF
   *
   */

#include "config.h"

#include <stdio.h>
#include <string.h>

#include <usb.h>
#include <jpeglib.h>

#include "debug.h"
#include "cfg.h"
#include "qprintf.h"
#include "timer.h"
#include "drv.h"

/* graphic display? */
#include "drv_generic_graphic.h"
#include "jpeg_mem_dest.h"

#define FILLSIZE 16384          // 16kB
#define HEADERSIZE 12

// Drivername for verbose output
static char Name[] = "SamsungSPF";

struct SPFdev {
    const char type[64];
    const int vendorID;
    struct {
        const int storageMode;
        const int monitorMode;
    } productID;
    const unsigned int xRes;
    const unsigned int yRes;
};

static struct SPFdev spfDevices[] = {
    {
     .type = "SPF-AUTO",
     .vendorID = 0x04e8,
     .productID = { 0xffff, 0xffff},
     .xRes = 1,
     .yRes = 1,
      },
    {
     .type = "SPF-72H",
     .vendorID = 0x04e8,
     .productID = { 0x200a, 0x200b},
     .xRes = 800,
     .yRes = 480,
      },
    {
     .type = "SPF-75H",
     .vendorID = 0x04e8,
     .productID = { 0x200e, 0x200f},
     .xRes = 800,
     .yRes = 480,
      },
    {
     .type = "SPF-76H",
     .vendorID = 0x04e8,
     .productID = { 0x200e, 0x200f},
     .xRes = 800,
     .yRes = 480,
      },
    {
     .type = "SPF-83H",
     .vendorID = 0x04e8,
     .productID = { 0x200c, 0x200d},
     .xRes = 800,
     .yRes = 600,
      },
    {
     .type = "SPF-83M",
     .vendorID = 0x04e8,
     .productID = { 0x2005, 0x2006},
     .xRes = 800,
     .yRes = 600,
      },
    {
     .type = "SPF-85H",
     .vendorID = 0x04e8,
     .productID = { 0x2012, 0x2013},
     .xRes = 800,
     .yRes = 600,
      },
    {
     .type = "SPF-85P",
     .vendorID = 0x04e8,
     .productID = { 0x2016, 0x2017},
     .xRes = 800,
     .yRes = 600,
      },
    {
     .type = "SPF-86H",
     .vendorID = 0x04e8,
     .productID = { 0x2012, 0x2013},
     .xRes = 800,
     .yRes = 600,
      },
    {
     .type = "SPF-86P",
     .vendorID = 0x04e8,
     .productID = { 0x2016, 0x2017},
     .xRes = 800,
     .yRes = 600,
      },
    {
     .type = "SPF-87H",
     .vendorID = 0x04e8,
     .productID = { 0x2025, 0x2026},
     .xRes = 800,
     .yRes = 480,
      },
    {
     .type = "SPF-87H-v2",
     .vendorID = 0x04e8,
     .productID = { 0x2033, 0x2034},
     .xRes = 800,
     .yRes = 480,
      },
    {
     .type = "SPF-105P",
     .vendorID = 0x04e8,
     .productID = { 0x201c, 0x201b},
     .xRes = 1024,
     .yRes = 600,
      },
    {
     .type = "SPF-107H",
     .vendorID = 0x04e8,
     .productID = { 0x2027, 0x2028},
     .xRes = 1024,
     .yRes = 600,
      },
    {
     .type = "SPF-107H-v2",
     .vendorID = 0x04e8,
     .productID = { 0x2035, 0x2036},
     .xRes = 1024,
     .yRes = 600,
      },
    {
     .type = "SPF-700T",
     .vendorID = 0x04e8,
     .productID = { 0x204f, 0x2050},
     .xRes = 800,
     .yRes = 600,
      },
    {
     .type = "SPF-1000P",
     .vendorID = 0x04e8,
     .productID = { 0x2039, 0x2040},
     .xRes = 1024,
     .yRes = 600,
      },
};

static int numFrames = sizeof(spfDevices) / sizeof(spfDevices[0]);

struct usb_device *myDev;
usb_dev_handle *myDevHandle;
struct SPFdev *myFrame;

typedef struct {
    unsigned char R, G, B;
} RGB;

static struct {
    RGB *buf;
    int dirty;
    int fbsize;
} image;

static struct {
    unsigned char *buf;
    unsigned long int size;
} jpegImage;


/****************************************/
/***  hardware dependant functions    ***/
/****************************************/


/* please note that in-memory compression doesn't work satisfactory */
int convert2JPG()
{
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
    int row_stride;             /* physical row width in buffer */
    JSAMPROW row_pointer[1];    /* pointer to a single row */

    /* Initialize compression frame */
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    jpeg_mem_dest(&cinfo, &jpegImage.buf, &jpegImage.size);

    cinfo.image_width = myFrame->xRes;
    cinfo.image_height = myFrame->yRes;
    cinfo.input_components = sizeof(RGB);
    cinfo.in_color_space = JCS_RGB;

    /* call some jpeg helpers */
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, 100, 1);   /*set the quality [0..100]  */
    jpeg_start_compress(&cinfo, 1);

    row_stride = cinfo.image_width;

    /* Convert line by line */
    while (cinfo.next_scanline < cinfo.image_height) {
        row_pointer[0] = (JSAMPROW) (image.buf + (cinfo.next_scanline * row_stride));
        jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }

    /* Finish compression and free internal memory */
    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);

    return 0;
}


// Find specific Samsung device
static void drv_SamsungSPF_find()
{
    info("%s: Searching SPF.", Name);

    /* open USB device */
    struct usb_bus *bus;
    struct usb_device *dev;
    int i;

    usb_init();
    usb_find_busses();
    usb_find_devices();

    for (bus = usb_busses; bus; bus = bus->next) {
        for (dev = bus->devices; dev; dev = dev->next) {
            if (dev->descriptor.idVendor == myFrame->vendorID) {
                if (myFrame->productID.storageMode == 0xFFFF) {
                    for (i = 0; i < numFrames; i++) {
                        if (dev->descriptor.idProduct == spfDevices[i].productID.storageMode) {

                            info("Samsung photoframe in Mass Storage mode found.");
                            myFrame = &spfDevices[i];
                            info("%s: Autodetect model %s.", Name, spfDevices[i].type);
                            myDev = dev;

                            return;
                        } else if (dev->descriptor.idProduct == spfDevices[i].productID.monitorMode) {

                            info("Samsung photoframe in Custom Product mode found.");
                            myFrame = &spfDevices[i];
                            info("%s: Autodetect model %s.", Name, spfDevices[i].type);
                            myDev = dev;

                            return;
                        }
                    }
                } else {
                    if (dev->descriptor.idProduct == myFrame->productID.storageMode) {

                        info("Samsung photoframe in Mass Storage mode found.");
                        myDev = dev;

                        return;
                    } else if (dev->descriptor.idProduct == myFrame->productID.monitorMode) {

                        info("Samsung photoframe in Custom Product mode found.");
                        myDev = dev;

                        return;
                    }
                }
            }
        }
    }

    free(bus);
    myDev = 0;
}


static int drv_SamsungSPF_open()
{
    if (!myDev) {
        error("%s: No device specified!", Name);
        return -1;
    }

    int res = -1;
    char buf[256];

    if (myDev->descriptor.idProduct == myFrame->productID.storageMode) {
        info("%s: Opening device and switching to monitor mode", Name);

        myDevHandle = usb_open(myDev);

#if 0
        setuid(getuid());
#endif

        strcpy(buf, "** no string **");
        res = usb_get_string_simple(myDevHandle, myDev->descriptor.iManufacturer, buf, sizeof(buf));
        debug("usb_get_string_simple => %d, %s", res, buf);

        memset(buf, 0, 256);

        res = usb_control_msg(myDevHandle, USB_TYPE_STANDARD | USB_ENDPOINT_IN,
                              USB_REQ_GET_DESCRIPTOR, 0xfe, 0xfe, buf, 0xfe, 1000);
        /* usb_close( myDev ); */
        usb_close(myDevHandle);
        // Sleep some time before research
        sleep(1);
        drv_SamsungSPF_find();
    } else
        info("%s: No device in storage mode found", Name);

    if (myDev->descriptor.idProduct == myFrame->productID.storageMode) {
        error("%s: Was not able to switch to monitor mode!", Name);
        return -1;
    }

    if (myDev->descriptor.idProduct == myFrame->productID.monitorMode) {
        info("%s: Device '%s' is now in monitor mode.", Name, myFrame->type);
        myDevHandle = usb_open(myDev);
        return 0;
    }

    error("Unknown error: usb_control_msg() = %d", res);
    return -1;
}


/* dummy function that sends something to the display */
static int drv_SamsungSPF_send(char *data, unsigned int len)
{
    char usb_hdr[HEADERSIZE] = { 0xa5, 0x5a, 0x18, 0x04, 0xff, 0xff,
        0xff, 0xff, 0x48, 0x00, 0x00, 0x00
    };
#if 0
    char buffer[1] = { 0x0 };
#endif
    int usb_timeout = 1000;
    int usb_endpoint = 0x2;
    int ret;

    *(int *) (usb_hdr + 4) = len;

    debug("bytes_to_send: %d, offset: %d", len, HEADERSIZE);

#if 0
    /* Send USB header */
    if ((ret = usb_bulk_write(myDevHandle, usb_endpoint, usb_hdr, 12, usb_timeout)) < 0) {
        error("%s: Error occurred while writing data to device.", Name);
        error("%s: usb_bulk_write returned: %d", Name, ret);
        return -1;
    }

    /* Send JPEG image */
    if ((ret = usb_bulk_write(myDevHandle, usb_endpoint, data, len, usb_timeout)) < 0) {
        error("%s: Error occurred while writing data to device.", Name);
        error("%s: usb_bulk_write returned: %d", Name, ret);
        return -1;
    }

    /* Finish transmission by sending zero */
    if ((ret = usb_bulk_write(myDevHandle, usb_endpoint, buffer, 1, usb_timeout)) < 0) {
        error("%s: Error occurred while writing data to device.", Name);
        error("%s: usb_bulk_write returned: %d", Name, ret);
        return -1;
    }
#endif

    char *buffer;
    unsigned int rest = FILLSIZE - ((len + HEADERSIZE) % FILLSIZE);     /* +1; */
    unsigned int full = HEADERSIZE + len + rest;

    debug("calculated full bytes_to_send:: %d", full);

    buffer = malloc(full + FILLSIZE);   //added FILLSIZE is just for safety
    if (buffer != NULL) {
        int i;
        for (i = 0; i < HEADERSIZE; i++)
            buffer[i] = usb_hdr[i];
        memset(buffer + HEADERSIZE + len, 0x00, rest);
        memcpy(buffer + HEADERSIZE, data, len);
        if ((ret = usb_bulk_write(myDevHandle, usb_endpoint, buffer, full, usb_timeout)) < 0) {
            error("%s: Error occurred while writing data to device.", Name);
            error("%s: usb_bulk_write returned: %d", Name, ret);
            free(buffer);
            return -1;
        } else {
            free(buffer);
        }
    } else {
        error("%s: Not enough free memory.", Name);
        return -1;
    }

    /* Keep SPF87h and friends in MiniMonitorMode */
    char bytes[] = { 0x09, 0x04 };

    if ((ret = usb_control_msg(myDevHandle, 0xc0, 0x01, 0x0000, 0x0000, bytes, 0x02, 1000)) < 0) {
        error("%s: Error occurred while sending control_msg to device.", Name);
        error("%s: usb_control_msg returned: %d", Name, ret);
    };

    return 0;
}


/* for graphic displays only */
static void drv_SamsungSPF_blit(const int row, const int col, const int height, const int width)
{
    int r, c;

    for (r = row; r < row + height; r++) {
        for (c = col; c < col + width; c++) {
            RGB p1 = image.buf[r * myFrame->xRes + c];
            RGBA p2 = drv_generic_graphic_rgb(r, c);
            if (p1.R != p2.R || p1.G != p2.G || p1.B != p2.B) {
                image.buf[r * myFrame->xRes + c].R = p2.R;
                image.buf[r * myFrame->xRes + c].G = p2.G;
                image.buf[r * myFrame->xRes + c].B = p2.B;
                image.dirty = 1;
            }
        }
    }
}


static void drv_SamsungSPF_timer( __attribute__((unused))
                                 void *notused)
{
    if (image.dirty) {
        debug("FB dirty, writing jpeg...");
        convert2JPG();

        /* Sent image to display */
        if ((drv_SamsungSPF_send((char *) jpegImage.buf, jpegImage.size)) != 0) {
            error("%s: Error occurred while sending jpeg image to device.", Name);
        }
        /* Clean dirty bit */
        image.dirty = 0;

        /* Free JPEG buffer since a new is allocated each time an image is
           compressed */
        if (jpegImage.size)
            free(jpegImage.buf);
        jpegImage.size = 0;
    }
}


/* start graphic display */
static int drv_SamsungSPF_start(const char *section)
{
    int timerInterval = 1000;
    char *s;

    cfg_number(section, "update", timerInterval, 0, -1, &timerInterval);
    debug("Updating display every %dms", timerInterval);

    DROWS = myFrame->yRes;
    DCOLS = myFrame->xRes;
    info("%s: Using SPF with %dx%d pixels.", Name, DCOLS, DROWS);

    s = cfg_get(section, "Font", "6x8");
    if (s == NULL || *s == '\0') {
        error("%s: no '%s.Font' entry from %s", Name, section, cfg_source());
        return -1;
    }

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

    if (XRES < 6 || YRES < 8) {
        error("%s: bad Font '%s' from %s (must be at least 6x8)", Name, s, cfg_source());
        return -1;
    }
    free(s);

    /* Allocate framebuffer */
    image.fbsize = myFrame->xRes * myFrame->yRes * sizeof(RGB);
    image.buf = malloc(image.fbsize);
    memset(image.buf, 128, image.fbsize);
    image.dirty = 0;

    /* JPEG buffer is allocated by jpeglib */
    jpegImage.buf = 0;
    jpegImage.size = 0;

    /* regularly transmit the image */
    timer_add(drv_SamsungSPF_timer, NULL, timerInterval, 0);

    return 0;
}



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


/* list models */
int drv_SamsungSPF_list(void)
{
    int i;

    printf("SamsungSPF driver, supported models [");
    for (i = 0; i < numFrames; i++) {
        printf("%s", spfDevices[i].type);
        if (i < numFrames - 1)
            printf(", ");
    }
    printf("]\n");

    return 0;
}


/* initialize driver & display */
/* use this function for a graphic display */
int drv_SamsungSPF_init(const char *section, const int quiet)
{
    info("%s: Initializing SPF.", Name);

    char *s;
    int i;

    myDev = 0;
    myFrame = 0;

    // Look for model entry in config
    s = cfg_get(section, "Model", NULL);
    if (s == NULL || *s != '\0') {
        s = cfg_get(section, "Model", NULL);
        if (s == NULL || *s == '\0') {

            drv_SamsungSPF_list();
            error("%s: no '%s.Model' entry from %s", Name, section, cfg_source());
            return -1;
        }
    }
    // Look for specified device
    for (i = 0; i < numFrames; i++) {
        if (strcasecmp(s, spfDevices[i].type) == 0) {
            myFrame = &spfDevices[i];
            info("%s: Configured for model %s.", Name, spfDevices[i].type);
            break;
        }
    }

    if (!myFrame) {
        drv_SamsungSPF_list();
        error("%s: unknown model '%s'!", Name, s);
        return -1;
    }

    free(s);

    /* try to open USB device */
    drv_SamsungSPF_find();
    while (!myDev)              //endless loop waitung for SPF
    {
        sleep(5);
        drv_SamsungSPF_find();
    }
    if (!myDev) {
        error("%s: No Samsung '%s' found!", Name, myFrame->type);
        return -1;
    }

    /* open display and switch to monitor mode if necessary */
    if (drv_SamsungSPF_open() == -1)
        return -1;

    int ret;

    /* real worker functions */
    drv_generic_graphic_real_blit = drv_SamsungSPF_blit;

    /* start display */
    if ((ret = drv_SamsungSPF_start(section)) != 0)
        return ret;

    /* initialize generic graphic driver */
    if ((ret = drv_generic_graphic_init(section, Name)) != 0)
        return ret;

    if (!quiet) {
        char buffer[40];
        qprintf(buffer, sizeof(buffer), "%s %dx%d", Name, DCOLS, DROWS);
        if (drv_generic_graphic_greet(buffer, NULL)) {
            sleep(3);
            drv_generic_graphic_clear();
        }
    }

    return 0;
}


/* close driver & display */
/* use this function for a graphic display */
int drv_SamsungSPF_quit(const int quiet)
{

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

    /* clear display */
    drv_generic_graphic_clear();

    /* say goodbye... */
    if (!quiet) {
        drv_generic_graphic_greet("goodbye!", NULL);
    }

    drv_generic_graphic_quit();

    debug("closing connection");
    printf("%s: Closing driver...\n", Name);
    usb_close(myDevHandle);
    free(myDev);
    free(myDevHandle);

    return (0);
}


/* use this one for a graphic display */
DRIVER drv_SamsungSPF = {
    .name = Name,
    .list = drv_SamsungSPF_list,
    .init = drv_SamsungSPF_init,
    .quit = drv_SamsungSPF_quit,
};