dtv-scan-tables.git - Digital TV scan tables

diff options

Diffstat (limited to 'dvb-t/uk-Ferryside')

0 files changed, 0 insertions, 0 deletions

/* $Id: drv_dpf.c 980 2009-01-28 21:18:52Z michux $ * $URL: https://ssl.bulix.org/svn/lcd4linux/trunk/drv_dpf.c $ * * Driver for hacked digital picture frames. Uses *NO* external libraries. * See http://dpf-ax.sourceforge.net/ for more information. * * Copyright (C) 2008 Jeroen Domburg <picframe@spritesmods.com> * Modified from sample code by: * Copyright (C) 2005 Michael Reinelt <michael@reinelt.co.at> * Copyright (C) 2005, 2006, 2007 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net> * * Mods by <hackfin@section5.ch> * Complete rewrite 05/2013 by superelchi <superelchi AT wolke7.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_DPF * */ #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_graphic.h" //################################################################### // Start dpfcore4driver.h // See http://dpf-ax.sourceforge.net/ //################################################################### #define DPFAXHANDLE void * // Handle needed for dpf_ax access #define DPF_BPP 2 //bpp for dfp-ax is currently always 2! /** * Open DPF device. * * Device must be string in the form "usbX" or "dpfX", with X = 0 .. number of connected dpfs. * The open function will scan the USB bus and return a handle to access dpf #X. * If dpf #X is not found, returns NULL. * * \param dev device name to open * \return device handle or NULL */ DPFAXHANDLE dpf_ax_open(const char *device); /** * Close DPF device. */ void dpf_ax_close(DPFAXHANDLE h); /** Blit data to screen. * * \param buf buffer to 16 bpp RGB 565 image data * \param rect rectangle tuple: [x0, y0, x1, y1] */ void dpf_ax_screen_blit(DPFAXHANDLE h, const unsigned char *buf, short rect[4]); /** Set backlight brightness. * * \param value Backlight value 0..7 (0 = off, 7 = max brightness) */ void dpf_ax_setbacklight(DPFAXHANDLE h, int value); /** Get screen width. * * \return width in pixel */ int dpf_ax_getwidth(DPFAXHANDLE h); /** Get screen height. * * \return height in pixel */ int dpf_ax_getheight(DPFAXHANDLE h); //################################################################### // End dpfcore4driver.h //################################################################### static char Name[] = "DPF"; /* * Dpf status */ static struct { unsigned char *lcdBuf; // Display data buffer unsigned char *xferBuf; // USB transfer buffer DPFAXHANDLE dpfh; // Handle for dpf access int pwidth; // Physical display width int pheight; // Physical display height // Flags to translate logical to physical orientation int isPortrait; int rotate90; int flip; // Current dirty rectangle int minx, maxx; int miny, maxy; // Config properties int orientation; int backlight; } dpf; // Convert RGBA pixel to RGB565 pixel(s) #define _RGB565_0(p) (( ((p.R) & 0xf8) ) | (((p.G) & 0xe0) >> 5)) #define _RGB565_1(p) (( ((p.G) & 0x1c) << 3 ) | (((p.B) & 0xf8) >> 3)) /* * Set one pixel in lcdBuf. * * Respects orientation and updates dirty rectangle. * * in: x, y - pixel coordinates * pix - RGBA pixel value * out: - */ static void drv_set_pixel(int x, int y, RGBA pix) { int changed = 0; int sx = DCOLS; int sy = DROWS; int lx = x % sx; int ly = y % sy; if (dpf.flip) { // upside down orientation lx = DCOLS - 1 - lx; ly = DROWS - 1 - ly; } if (dpf.rotate90) { // wrong Orientation, rotate int i = ly; ly = dpf.pheight - 1 - lx; lx = i; } if (lx < 0 || lx >= (int) dpf.pwidth || ly < 0 || ly >= (int) dpf.pheight) { error("dpf: x/y out of bounds (x=%d, y=%d, rot=%d, flip=%d, lx=%d, ly=%d)\n", x, y, dpf.rotate90, dpf.flip, lx, ly); return; } unsigned char c1 = _RGB565_0(pix); unsigned char c2 = _RGB565_1(pix); unsigned int i = (ly * dpf.pwidth + lx) * DPF_BPP; if (dpf.lcdBuf[i] != c1 || dpf.lcdBuf[i + 1] != c2) { dpf.lcdBuf[i] = c1; dpf.lcdBuf[i + 1] = c2; changed = 1; } if (changed) { if (lx < dpf.minx) dpf.minx = lx; if (lx > dpf.maxx) dpf.maxx = lx; if (ly < dpf.miny) dpf.miny = ly; if (ly > dpf.maxy) dpf.maxy = ly; } } /* * Send pixel data to dpf */ static void drv_dpf_blit(const int row, const int col, const int height, const int width) { int x, y; // Set pixels one by one // Note: here is room for optimization :-) for (y = row; y < row + height; y++) for (x = col; x < col + width; x++) drv_set_pixel(x, y, drv_generic_graphic_rgb(y, x)); // If nothing has changed, skip transfer if (dpf.minx > dpf.maxx || dpf.miny > dpf.maxy) return; // Copy data in dirty rectangle from data buffer to temp transfer buffer unsigned int cpylength = (dpf.maxx - dpf.minx + 1) * DPF_BPP; unsigned char *ps = dpf.lcdBuf + (dpf.miny * dpf.pwidth + dpf.minx) * DPF_BPP; unsigned char *pd = dpf.xferBuf; for (y = dpf.miny; y <= dpf.maxy; y++) { memcpy(pd, ps, cpylength); ps += dpf.pwidth * DPF_BPP; pd += cpylength; } // Send the buffer short rect[4]; rect[0] = dpf.minx; rect[1] = dpf.miny; rect[2] = dpf.maxx + 1; rect[3] = dpf.maxy + 1; dpf_ax_screen_blit(dpf.dpfh, dpf.xferBuf, rect); // Reset dirty rectangle dpf.minx = dpf.pwidth - 1; dpf.maxx = 0; dpf.miny = dpf.pheight - 1; dpf.maxy = 0; } /* start graphic display */ static int drv_dpf_start(const char *section) { int i; char *dev; char *s; // Check if config is valid // Get the device dev = cfg_get(section, "Port", NULL); if (dev == NULL || *dev == '\0') { error("dpf: no '%s.Port' entry from %s", section, cfg_source()); return -1; } // Get font 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; } /* we dont want fonts below 6 width */ if (XRES < 6) { error("%s: bad Font '%s' width '%d' using minimum of 6)", Name, s, XRES); XRES = 6; } /* we dont want fonts below 8 height */ if (YRES < 8) { error("%s: bad Font '%s' height '%d' using minimum of 8)", Name, s, YRES); YRES = 8; } // Get the logical orientation (0 = landscape, 1 = portrait, 2 = reverse landscape, 3 = reverse portrait) if (cfg_number(section, "Orientation", 0, 0, 3, &i) > 0) dpf.orientation = i; else dpf.orientation = 0; // Get the backlight value (0 = off, 7 = max brightness) if (cfg_number(section, "Backlight", 0, 0, 7, &i) > 0) dpf.backlight = i; else dpf.backlight = 7; /* open communication with the display */ dpf.dpfh = dpf_ax_open(dev); if (dpf.dpfh == NULL) { error("dpf: cannot open dpf device %s", dev); return -1; } // Get dpfs physical dimensions dpf.pwidth = dpf_ax_getwidth(dpf.dpfh); dpf.pheight = dpf_ax_getheight(dpf.dpfh); // See, if we have to rotate the display dpf.isPortrait = dpf.pwidth < dpf.pheight; if (dpf.isPortrait) { if (dpf.orientation == 0 || dpf.orientation == 2) dpf.rotate90 = 1; } else if (dpf.orientation == 1 || dpf.orientation == 3) dpf.rotate90 = 1; dpf.flip = (!dpf.isPortrait && dpf.rotate90); // adjust to make rotate por/land = physical por/land if (dpf.orientation > 1) dpf.flip = !dpf.flip; // allocate display buffer + temp transfer buffer dpf.lcdBuf = malloc(dpf.pwidth * dpf.pheight * DPF_BPP); dpf.xferBuf = malloc(dpf.pwidth * dpf.pheight * DPF_BPP); // clear display buffer + set it to "dirty" memset(dpf.lcdBuf, 0, dpf.pwidth * dpf.pheight * DPF_BPP); //Black dpf.minx = 0; dpf.maxx = dpf.pwidth - 1; dpf.miny = 0; dpf.maxy = dpf.pheight - 1; // set the logical width/height for lcd4linux DCOLS = ((!dpf.rotate90) ? dpf.pwidth : dpf.pheight); DROWS = ((!dpf.rotate90) ? dpf.pheight : dpf.pwidth); // Set backlight (brightness) dpf_ax_setbacklight(dpf.dpfh, dpf.backlight); return 0; } /****************************************/ /*** plugins ***/ /****************************************/ static void plugin_backlight(RESULT * result, RESULT * arg1) { int b = R2N(arg1); if (b < 0) b = 0; if (b > 7) b = 7; dpf_ax_setbacklight(dpf.dpfh, b); SetResult(&result, R_NUMBER, &b); } /****************************************/ /*** exported functions ***/ /****************************************/ /* list models */ int drv_dpf_list(void) { printf("Hacked dpf-ax digital photo frame"); return 0; } /* initialize driver & display */ int drv_dpf_init(const char *section, const int quiet) { int ret; /* real worker functions */ drv_generic_graphic_real_blit = drv_dpf_blit; /* start display */ if ((ret = drv_dpf_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(); } } /* register plugins */ AddFunction("LCD::backlight", 1, plugin_backlight); return 0; } /* close driver & display */ int drv_dpf_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"); dpf_ax_close(dpf.dpfh); return (0); } DRIVER drv_DPF = { .name = Name, .list = drv_dpf_list, .init = drv_dpf_init, .quit = drv_dpf_quit, }; //################################################################### // Start dpfcore4driver.c // See http://dpf-ax.sourceforge.net/ //################################################################### #include <usb.h> #define AX206_VID 0x1908 // Hacked frames USB Vendor ID #define AX206_PID 0x0102 // Hacked frames USB Product ID #define USBCMD_SETPROPERTY 0x01 // USB command: Set property #define USBCMD_BLIT 0x12 // USB command: Blit to screen /* Generic SCSI device stuff */ #define DIR_IN 0 #define DIR_OUT 1 /* The DPF context structure */ typedef struct dpf_context { usb_dev_handle *udev; unsigned int width; unsigned int height; } DPFContext; static int wrap_scsi(DPFContext * h, unsigned char *cmd, int cmdlen, char out, unsigned char *data, unsigned long block_len); /** * Open DPF device. * * Device must be string in the form "usbX" or "dpfX", with X = 0 .. number of connected dpfs. * The open function will scan the USB bus and return a handle to access dpf #X. * If dpf #X is not found, returns NULL. * * \param dev device name to open * \return device handle or NULL */ DPFAXHANDLE dpf_ax_open(const char *dev) { DPFContext *dpf; int index = -1; usb_dev_handle *u; if (dev && strlen(dev) == 4 && (strncmp(dev, "usb", 3) == 0 || strncmp(dev, "dpf", 3) == 0)) index = dev[3] - '0'; if (index < 0 || index > 9) { fprintf(stderr, "dpf_ax_open: wrong device '%s'. Please specify a string like 'usb0'\n", dev); return NULL; } usb_init(); usb_find_busses(); usb_find_devices(); struct usb_bus *b = usb_get_busses(); struct usb_device *d = NULL; int enumeration = 0; int found = 0; while (b && !found) { d = b->devices; while (d) { if ((d->descriptor.idVendor == AX206_VID) && (d->descriptor.idProduct == AX206_PID)) { fprintf(stderr, "dpf_ax_open: found AX206 #%d\n", enumeration + 1); if (enumeration == index) { found = 1; break; } else enumeration++; } d = d->next; } b = b->next; } if (!d) { fprintf(stderr, "dpf_ax_open: no matching USB device '%s' found!\n", dev); return NULL; } dpf = (DPFContext *) malloc(sizeof(DPFContext)); if (!dpf) { fprintf(stderr, "dpf_ax_open: error allocation memory.\n"); return NULL; } u = usb_open(d); if (u == NULL) { fprintf(stderr, "dpf_ax_open: failed to open usb device '%s'!\n", dev); free(dpf); return NULL; } if (usb_claim_interface(u, 0) < 0) { fprintf(stderr, "dpf_ax_open: failed to claim usb device!\n"); usb_close(u); free(dpf); return NULL; } dpf->udev = u; static unsigned char buf[5]; static unsigned char cmd[16] = { 0xcd, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; cmd[5] = 2; // get LCD parameters if (wrap_scsi(dpf, cmd, sizeof(cmd), DIR_IN, buf, 5) == 0) { dpf->width = (buf[0]) | (buf[1] << 8); dpf->height = (buf[2]) | (buf[3] << 8); fprintf(stderr, "dpf_ax_open: got LCD dimensions: %dx%d\n", dpf->width, dpf->height); } else { fprintf(stderr, "dpf_ax_open: error reading LCD dimensions!\n"); dpf_ax_close(dpf); return NULL; } return (DPFAXHANDLE) dpf; } /** * Close DPF device */ void dpf_ax_close(DPFAXHANDLE h) { DPFContext *dpf = (DPFContext *) h; usb_release_interface(dpf->udev, 0); usb_close(dpf->udev); free(dpf); } /** Get screen width. * * \return width in pixel */ int dpf_ax_getwidth(DPFAXHANDLE h) { return ((DPFContext *) h)->width; } /** Get screen height. * * \return height in pixel */ int dpf_ax_getheight(DPFAXHANDLE h) { return ((DPFContext *) h)->height; } static unsigned char g_excmd[16] = { 0xcd, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; /** Blit data to screen. * * \param buf buffer to 16 bpp RGB 565 image data * \param rect rectangle tuple: [x0, y0, x1, y1] */ void dpf_ax_screen_blit(DPFAXHANDLE h, const unsigned char *buf, short rect[4]) { unsigned long len = (rect[2] - rect[0]) * (rect[3] - rect[1]); len <<= 1; unsigned char *cmd = g_excmd; cmd[6] = USBCMD_BLIT; cmd[7] = rect[0]; cmd[8] = rect[0] >> 8; cmd[9] = rect[1]; cmd[10] = rect[1] >> 8; cmd[11] = rect[2] - 1; cmd[12] = (rect[2] - 1) >> 8; cmd[13] = rect[3] - 1; cmd[14] = (rect[3] - 1) >> 8; cmd[15] = 0; wrap_scsi((DPFContext *) h, cmd, sizeof(g_excmd), DIR_OUT, (unsigned char *) buf, len); } /** Set backlight * * \param value Backlight value 0..7 (0 = off, 7 = max brightness) */ void dpf_ax_setbacklight(DPFAXHANDLE h, int b) { unsigned char *cmd = g_excmd; if (b < 0) b = 0; if (b > 7) b = 7; cmd[6] = USBCMD_SETPROPERTY; cmd[7] = 0x01; // PROPERTY_BRIGHTNESS cmd[8] = 0x00; //PROPERTY_BRIGHTNESS >> 8; cmd[9] = b; cmd[10] = b >> 8; wrap_scsi((DPFContext *) h, cmd, sizeof(g_excmd), DIR_OUT, NULL, 0); } static unsigned char g_buf[] = { 0x55, 0x53, 0x42, 0x43, // dCBWSignature 0xde, 0xad, 0xbe, 0xef, // dCBWTag 0x00, 0x80, 0x00, 0x00, // dCBWLength 0x00, // bmCBWFlags: 0x80: data in (dev to host), 0x00: Data out 0x00, // bCBWLUN 0x10, // bCBWCBLength // SCSI cmd: 0xcd, 0x00, 0x00, 0x00, 0x00, 0x06, 0x11, 0xf8, 0x70, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, }; #define ENDPT_OUT 1 #define ENDPT_IN 0x81 static int wrap_scsi(DPFContext * h, unsigned char *cmd, int cmdlen, char out, unsigned char *data, unsigned long block_len) { int len; int ret; static unsigned char ansbuf[13]; // Do not change size. g_buf[14] = cmdlen; memcpy(&g_buf[15], cmd, cmdlen); g_buf[8] = block_len; g_buf[9] = block_len >> 8; g_buf[10] = block_len >> 16; g_buf[11] = block_len >> 24; ret = usb_bulk_write(h->udev, ENDPT_OUT, (const char *) g_buf, sizeof(g_buf), 1000); if (ret < 0) return ret; if (out == DIR_OUT) { if (data) { ret = usb_bulk_write(h->udev, ENDPT_OUT, (const char *) data, block_len, 3000); if (ret != (int) block_len) { fprintf(stderr, "dpf_ax ERROR: bulk write.\n"); return ret; } } } else if (data) { ret = usb_bulk_read(h->udev, ENDPT_IN, (char *) data, block_len, 4000); if (ret != (int) block_len) { fprintf(stderr, "dpf_ax ERROR: bulk read.\n"); return ret; } } // get ACK: len = sizeof(ansbuf); int retry = 0; int timeout = 0; do { timeout = 0; ret = usb_bulk_read(h->udev, ENDPT_IN, (char *) ansbuf, len, 5000); if (ret != len) { fprintf(stderr, "dpf_ax ERROR: bulk ACK read.\n"); timeout = 1; } retry++; } while (timeout && retry < 5); if (strncmp((char *) ansbuf, "USBS", 4)) { fprintf(stderr, "dpf_ax ERROR: got invalid reply\n."); return -1; } // pass back return code set by peer: return ansbuf[12]; } //################################################################### // End dpfcore4driver.c //###################################################################


context:
space:
mode: