/* $Id: udelay.c,v 1.14 2003/10/12 04:46:19 reinelt Exp $ * * short delays * * Copyright 1999, 2000 Michael Reinelt * * 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. * * * $Log: udelay.c,v $ * Revision 1.14 2003/10/12 04:46:19 reinelt * * * first try to integrate the Evaluator into a display driver (MatrixOrbital here) * small warning in processor.c fixed (thanks to Zachary Giles) * workaround for udelay() on alpha (no msr.h avaliable) (thanks to Zachary Giles) * * Revision 1.13 2003/10/05 17:58:50 reinelt * libtool junk; copyright messages cleaned up * * Revision 1.12 2003/07/18 04:43:14 reinelt * udelay: unnecessary sanity check removed * * Revision 1.11 2003/04/04 06:02:04 reinelt * new parallel port abstraction scheme * * Revision 1.10 2003/02/27 07:43:11 reinelt * * asm/msr.h: included hard-coded definition of rdtscl() if msr.h cannot be found. * * autoconf/automake/autoanything: switched back to 1.4. Hope it works again. * * Revision 1.9 2002/08/21 06:09:53 reinelt * some T6963 fixes, ndelay wrap * * Revision 1.8 2002/08/17 14:14:21 reinelt * * USBLCD fixes * * Revision 1.7 2002/04/29 11:00:28 reinelt * * added Toshiba T6963 driver * added ndelay() with nanosecond resolution * * Revision 1.6 2001/08/08 05:40:24 reinelt * * renamed CLK_TCK to CLOCKS_PER_SEC * * Revision 1.5 2001/03/12 13:44:58 reinelt * * new udelay() using Time Stamp Counters * * Revision 1.4 2001/03/12 12:39:36 reinelt * * reworked autoconf a lot: drivers may be excluded, #define's went to config.h * * Revision 1.3 2001/03/01 22:33:50 reinelt * * renamed Raster_flush() to PPM_flush() * * Revision 1.2 2000/07/31 10:43:44 reinelt * * some changes to support kernel-2.4 (different layout of various files in /proc) * * Revision 1.1 2000/04/15 16:56:52 reinelt * * moved delay loops to udelay.c * renamed -d (debugging) switch to -v (verbose) * new switch -d to calibrate delay loop * 'Delay' entry for HD44780 back again * delay loops will not calibrate automatically, because this will fail with hich CPU load * */ /* * * exported fuctions: * * void udelay (unsigned long usec) * delays program execution for usec microseconds * uses global variable 'loops_per_usec', which has to be set before. * This function does busy-waiting! so use only for delays smaller * than 10 msec * * void udelay_calibrate (void) (if USE_OLD_UDELAY is defined) * does a binary approximation for 'loops_per_usec' * should be called several times on an otherwise idle machine * the maximum value should be used * * void udelay_init (void) * selects delay method (gettimeofday() ord rdtsc() according * to processor features * */ #include "config.h" #include #include #ifdef USE_OLD_UDELAY #include #else #include #include #include #include #include #include #ifdef HAVE_ASM_MSR_H #include #endif #endif #include "debug.h" #include "udelay.h" #ifdef USE_OLD_UDELAY unsigned long loops_per_usec; void ndelay (unsigned long nsec) { unsigned long loop=(nsec*loops_per_usec+999)/1000; __asm__ (".align 16\n" "1:\tdecl %0\n" "\tjne 1b" : /* no result */ :"a" (loop)); } /* adopted from /usr/src/linux/init/main.c */ void udelay_calibrate (void) { clock_t tick; unsigned long bit; loops_per_usec=1; while (loops_per_usec<<=1) { tick=clock(); while (clock()==tick); tick=clock(); ndelay(1000000000/CLOCKS_PER_SEC); if (clock()>tick) break; } loops_per_usec>>=1; bit=loops_per_usec; while (bit>>=1) { loops_per_usec|=bit; tick=clock(); while (clock()==tick); tick=clock(); ndelay(1000000000/CLOCKS_PER_SEC); if (clock()>tick) loops_per_usec&=~bit; } } #else static unsigned int ticks_per_usec=0; static void getCPUinfo (int *hasTSC, double *MHz) { int fd; char buffer[4096], *p; *hasTSC=0; *MHz=-1; fd=open("/proc/cpuinfo", O_RDONLY); if (fd==-1) { error ("open(/proc/cpuinfo) failed: %s", strerror(errno)); return; } if (read (fd, &buffer, sizeof(buffer)-1)==-1) { error ("read(/proc/cpuinfo) failed: %s", strerror(errno)); close (fd); return; } close (fd); p=strstr(buffer, "flags"); if (p==NULL) { debug ("/proc/cpuinfo has no 'flags' line"); } else { p=strstr(p, "tsc"); if (p==NULL) { debug ("CPU does not support Time Stamp Counter"); } else { debug ("CPU supports Time Stamp Counter"); *hasTSC=1; } } p=strstr(buffer, "cpu MHz"); if (p==NULL) { debug ("/proc/cpuinfo has no 'cpu MHz' line"); } else { if (sscanf(p+7, " : %lf", MHz)!=1) { error ("parse(/proc/cpuinfo) failed: unknown 'cpu MHz' format"); *MHz=-1; } else { debug ("CPU runs at %f MHz", *MHz); } } } void udelay_init (void) { #ifdef HAVE_ASM_MSR_H int tsc; double mhz; getCPUinfo (&tsc, &mhz); if (tsc && mhz>0.0) { ticks_per_usec=ceil(mhz); debug ("using TSC delay loop, %u ticks per microsecond", ticks_per_usec); } else #endif { ticks_per_usec=0; debug ("using gettimeofday() delay loop"); } } void ndelay (unsigned long nsec) { #ifdef HAVE_ASM_MSR_H if (ticks_per_usec) { unsigned int t1, t2; nsec=(nsec*ticks_per_usec+999)/1000; rdtscl(t1); do { rep_nop(); rdtscl(t2); } while ((t2-t1)1000000) { end.tv_usec-=1000000; end.tv_sec++; } do { rep_nop(); gettimeofday(&now, NULL); } while (now.tv_sec==end.tv_sec?now.tv_usec124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 
/* $Id: drv_MilfordInstruments.c,v 1.3 2004/05/28 13:51:42 reinelt Exp $
 *
 * driver for Milford Instruments 'BPK' piggy-back serial interface board
 * for standard Hitachi 44780 compatible lcd modules.
 *
 * Copyright 2003,2004 Andy Baxter <andy@earthsong.free-online.co.uk>
 * Copyright 2004 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
 *
 * based on the MatrixOrbital driver which is
 * Copyright 1999, 2000 Michael Reinelt <reinelt@eunet.at>
 *
 * 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.
 *
 *
 * $Log: drv_MilfordInstruments.c,v $
 * Revision 1.3  2004/05/28 13:51:42  reinelt
 *
 * ported driver for Beckmann+Egle Mini-Terminals
 * added 'flags' parameter to serial_init()
 *
 * Revision 1.2  2004/05/26 11:37:36  reinelt
 *
 * Curses driver ported.
 *
 * Revision 1.1  2004/05/26 05:03:27  reinelt
 *
 * MilfordInstruments driver ported
 *
 */

/* 
 *
 * exported fuctions:
 *
 * struct DRIVER drv_MilfordInstruments
 *
 */

#include "config.h"

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

#include "debug.h"
#include "cfg.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_serial.h"


static char Name[]="MilfordInstruments";

typedef struct {
  int type;
  char *name;
  int rows;
  int cols;
} MODEL;

static MODEL Models[] = {
  { 216, "MI216",    2, 16 },
  { 220, "MI220",    2, 20 },
  { 240, "MI240",    2, 40 },
  { 420, "MI420",    4, 20 },
  { -1,  "unknown", -1, -1 },
};

static int  Model;


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

static void drv_MI_write (int row, int col, unsigned char *data, int len)
{
  char cmd[2] = "\376x";
  char ddbase = 128;
  if (row & 1) { // i.e. if row is 1 or 3
    ddbase += 64;
  }
  if (row & 2) { // i.e. if row is 0 or 2.
    ddbase += 20;
  }
  cmd[1] = (char)(ddbase+col);
  drv_generic_serial_write(cmd,2);

  drv_generic_serial_write (data, len);
}


static void drv_MI_defchar (int ascii, unsigned char *buffer)
{
  char cmd[2]="\376x";
  if (ascii<8) {
    cmd[1]=(char)(64+ascii*8);
    drv_generic_serial_write (cmd, 2);
    drv_generic_serial_write (buffer, 8);
  }
}


static int drv_MI_start (char *section)
{
  int i;  
  char *model;
  
  model = cfg_get(section, "Model", NULL);
  if (model == NULL && *model == '\0') {
    error ("%s: no '%s.Model' entry from %s", Name, section, cfg_source());
    return -1;
  }
  
  for (i=0; Models[i].type!=0xff; i++) {
    if (strcasecmp(Models[i].name, model)==0) break;
  }
  if (Models[i].type==0xff) {
    error ("%s: %s.Model '%s' is unknown from %s", Name, section, model, cfg_source());
    return -1;
  }
  Model=i;
  info ("%s: using model '%s'", Name, Models[Model].name);
  
  if (drv_generic_serial_open(section, Name, 0)<0) return -1;
  
  // initialize global variables
  DROWS    = Models[Model].rows;
  DCOLS    = Models[Model].cols;
  
  drv_generic_serial_write ("\376\001", 2);  // clear screen
  drv_generic_serial_write ("\376\014", 2);  // cursor off

  return 0;
}


// ****************************************
// ***            plugins               ***
// ****************************************

// none at the moment...


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

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


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


// list models
int drv_MI_list (void)
{
  int i;
  
  for (i = 0; Models[i].type > 0; i++) {
    printf ("%s ", Models[i].name);
  }
  return 0;
}


// initialize driver & display
int drv_MI_init (char *section)
{
  WIDGET_CLASS wc;
  int ret;  
  
  // display preferences
  XRES  = 5;     // pixel width of one char 
  YRES  = 8;     // pixel height of one char 
  CHARS = 8;     // number of user-defineable characters
  CHAR0 = 0;     // ASCII of first user-defineable char
  GOTO_COST = 2; // number of bytes a goto command requires
  
  // real worker functions
  drv_generic_text_real_write   = drv_MI_write;
  drv_generic_text_real_defchar = drv_MI_defchar;


  // start display
  if ((ret=drv_MI_start (section))!=0)
    return ret;
  
  // initialize generic text driver
  if ((ret=drv_generic_text_init(section, Name))!=0)
    return ret;

  // initialize generic icon driver
  if ((ret=drv_generic_text_icon_init())!=0)
    return ret;
  
  // initialize generic bar driver
  if ((ret=drv_generic_text_bar_init(0))!=0)
    return ret;
  
  // add fixed chars to the bar driver
  drv_generic_text_bar_add_segment (  0,  0,255, 32); // ASCII  32 = blank
  drv_generic_text_bar_add_segment (255,255,255,255); // ASCII 255 = block
  
  // register text widget
  wc=Widget_Text;
  wc.draw=drv_generic_text_draw;
  widget_register(&wc);
  
  // register icon widget
  wc=Widget_Icon;
  wc.draw=drv_generic_text_icon_draw;
  widget_register(&wc);
  
  // register bar widget
  wc=Widget_Bar;
  wc.draw=drv_generic_text_bar_draw;
  widget_register(&wc);
  
  // register plugins
  // none at the moment...

  return 0;
}


// close driver & display
int drv_MI_quit (void) {

  info("%s: shutting down.", Name);
  drv_generic_serial_close();
  drv_generic_text_quit();
  
  return (0);
}


DRIVER drv_MilfordInstruments = {
  name: Name,
  list: drv_MI_list,
  init: drv_MI_init,
  quit: drv_MI_quit, 
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-29 08:33:12 +0000