[*** Just copy the following into a text editor and save as a60-lcd.c then 
build by typing make a60-lcd from a terminal: ***]


#include <stdio.h>
#include <stdlib.h>
#include <linux/ioctl.h>
#include <linux/parport.h>
#include <linux/ppdev.h>
#include <fcntl.h>
#include <time.h>

int fd;
int data = 0x7f;

/*
 * Linux tester for Siemens A60 LCD (A65, M55, C60, MC60, S55, etc)
 *
 * Connect signals to parallel port via ~10K resistors thus: -
 *
 * Parallel Port            A60-LCD
 *   2   D0     <--10K->     1  CS
 *   3   D1     <--10K->     2  Reset
 *   4   D2     <--10K->     3  RS
 *   5   D3     <--10K->     4  SCL
 *   6   D4     <--10K->     5  SDA
 *   7   D5     <-620R->     6  +2.9V *and* 8 A1
 *   8   D6     <-620R->    10  A2
 *  25   GND    <------>     7  GND   *and* 9 K
 *
 * LCD pad 1 is nearest the edge of the frame, pad 10 is nearest the
 * middle of the assembly.
 *
 * By coincidence, Vf of the backlight LEDs is approx 2.9V, thus
 * one can be used as a simple shunt regulator for the LCD supply.
 *
 * Remember, the series resistor limits the current in the shunt.
 * The series resistors in the signal lines limit the current in
 * the LCD's clamp diodes. Adjust values as necessary to suit the
 * specific parallel port.
 *
 * Make sure you have your distro's ppdev package installed.
 */

void Send (X)
{
    int mask;
    
    /* clock a byte out serially to the LCD */
    
    for (mask = 0x80; mask; mask >>= 1)
    //for (mask = 0x01; mask & 0x100; mask <<= 1)
    {
        if (mask & X)
            data |= 0x10;
        else
            data &= ~0x10;
        data &= ~0x08;
        ioctl (fd, PPWDATA, &data);
        //ioctl (fd, PPWDATA, &data);
        
        data |= 0x08;
        ioctl (fd, PPWDATA, &data);
        //ioctl (fd, PPWDATA, &data);
    }
}

void Initialise (void)
{
    int i, flag;
    int Sequence [] =
    {
        0xf4, 0x90, 0xb3, 0xa0, 0xd0, -1,
        0xf0, 0xe2, 0xd4, 0x70, 0x66, 0xb2, 0xba, 0xa1, 0xa3, 0xab, 
            0x94, 0x95, 0x95, 0x95, -1,
        0xf5, 0x90, -1,
        0xf1, 0x00, 0x10, 0x22, 0x30, 0x45, 0x50, 0x68, 0x70, 0x8a,
            0x90, 0xac, 0xb0, 0xce, 0xd0, -1,
        0xf2, 0x0f, 0x10, 0x20, 0x30, 0x43, 0x50, 0x66, 0x70, 0x89, 
            0x90, 0xab, 0xb0, 0xcd, 0xd0, -1,
        0xf3, 0x0e, 0x10, 0x2f, 0x30, 0x40, 0x50, 0x64, 0x70, 0x87,
            0x90, 0xaa, 0xb0, 0xcb, 0xd0, -1,
        0xf4, 0x0d, 0x10, 0x2e, 0x30, 0x4f, 0x50, -1,
        0xf5, 0x91, -1,
        0xf1, 0x01, 0x11, 0x22, 0x31, 0x43, 0x51, 0x64, 0x71, 0x86,
            0x91, 0xa8, 0xb1, 0xcb, 0xd1, -1,
        0xf2, 0x0f, 0x11, 0x21, 0x31, 0x42, 0x51, 0x63, 0x71, 0x85,
            0x91, 0xa6, 0xb1, 0xc8, 0xd1, -1,
        0xf3, 0x0b, 0x11, 0x2f, 0x31, 0x41, 0x51, 0x62, 0x71, 0x83,
            0x91, 0xa4, 0xb1, 0xc6, 0xd1, -1,
        0xf4, 0x08, 0x11, 0x2b, 0x31, 0x4f, 0x51, -1,
        0x80, 0x94, -1,
        0xf5, 0xa2, -1,
        0xf4, 0x60, -1,
        0xf0, 0x40, 0x50, 0xc0, -1,
        0xf4, 0x70, -1, -1,
        0xf0, 0x81, -1,
        0xf4, 0xb3, 0xa0, -1,
        0xf0, 0x00 | 0x6, 0x10, 0x20, 0x30, -1,
        0xf5, 0x00 | 0xf, 0x10 | 0xc, 0x20 | 0xf, 0x30 | 0x4, -1,
        -1, -1
    };

    /* power off */
    data = 0;
    ioctl (fd, PPWDATA, &data);
    usleep (500000);

    /* power on, reset */
    data = 0x7d;
    ioctl (fd, PPWDATA, &data);
    usleep (10000);
    
    /* reset off */
    data |= 0x02;
    ioctl (fd, PPWDATA, &data);
    usleep (10000);
    
    /* send commands */
    i = 0;
    data &= ~0x01;
    data |=  0x04;
    ioctl (fd, PPWDATA, &data);
    
    flag = 1;   
    do
    {
        Send (Sequence [i++]);
        
        if (Sequence [i] == -1)
        {
            data |= 0x01;
            ioctl (fd, PPWDATA, &data);
            usleep (1);
            
            data &= ~0x01;
            ioctl (fd, PPWDATA, &data);
            
            i++;
        }
        
        if (Sequence [i] == -1)
        {
            usleep (20000);
            i++;
        }
    } while (Sequence [i] != -1);
    
    /* select data register */
    data &= ~0x04;
    ioctl (fd, PPWDATA, &data); 
    /* good to go! */
}

void PowerOff (void)
{
    data = 0;
    ioctl (fd, PPWDATA, &data);
}

void SetWindow (int x, int y, int sx, int sy)
{
    /* bounds checking */
    sx += x;
    if (x < 0) x = 0;
    if (x > 100) x = 100;
    if (sx <= x) sx = x + 1;
    if (sx > 101) sx = 101;
    
    sy += y;
    if (y < 0) y = 0;
    if (y > 79) y = 79;
    if (sy <= y) sy = y + 1;
    if (sy > 80) sy = 80;
    
    /* send command */
    x = 2 * (3 + x);
    sx = 2 * (3 + sx) + 1;
    data |=  0x04;
    data &= ~0x01;
    ioctl (fd, PPWDATA, &data);
    
    Send (0xf0);
    Send (0x00 | (x & 0x0f));
    Send (0x10 | (x >> 4));
    Send (0x20 | (y & 0x0f));
    Send (0x30 | (y >> 4));
    
    Send (0xf5);
    Send (0x00 | (sx & 0x0f));
    Send (0x10 | (sx >> 4));
    Send (0x20 | (sy & 0x0f));
    Send (0x30 | (sy >> 4));
    
    data &= ~0x04;
    data |=  0x01;
    ioctl (fd, PPWDATA, &data);
}

int main (int argc, char *argv[])
{
    int i, j, k, demo;
    
    /* open the parallel port driver */
    fd = open ("/dev/parport0", O_RDWR);
    if (fd == -1)
    {
        perror ("open");
        exit (1);
    }

    if (ioctl (fd, PPCLAIM))
    {
        perror ("PPCLAIM");
        close (fd);
        exit (1);
    }

/*  mode = IEEE1284_MODE_COMPAT;
    if (ioctl (fd, PPNEGOT, &mode))
    {
        perror ("PPNEGOT");
        close (fd);
        exit (1);
    } */
    
    if (argc > 1 && argv[1][0] == '0')
    {
        PowerOff ();
        close (fd);
        exit (0);
    }

    if (argc < 2 || argv[1][0] != 's')
    {
        Initialise ();
    }
    
    demo = (argc > 1 && argv[1][0] == 'd');
    k = 0;
    do
    {
        for (i = 0; i < 80; i++)
        {
            SetWindow (0, i, 101, 1);
        
            data &= ~0x01;
            ioctl (fd, PPWDATA, &data);
            for (j = 0; j < 101; j++)
            {
                if (demo)
                {
                    int x, c;
                    x = ((i + k) ^ (j - k)) & 0xFF;
                    c = ((x >> 4) % 7) + 1;
                    x &= 0x0F;
            
                    Send  ((c & 0x01)? x: 0);
                    Send (((c & 0x02)? x << 4: 0) |
                          ((c & 0x04)? x: 0));
                }
                else
                {
                    int r, g, b;
                    r = getchar ();
                    g = getchar ();
                    b = getchar ();
                    Send  ((r >> 4) & 0x0F);
                    Send (((b >> 4) & 0x0F) |
                           (g & 0xF0));
                }
            }
            data |=  0x01;
            ioctl (fd, PPWDATA, &data);
        }
        k++;
        usleep (100000);
    } while (demo);
    
    close (fd);
    return 0;
}