got several different spaceballs to work / any interest presently in spaceballs ?

[Allen R. L. <all...@ch...>]

Any other out there interested in the spaceball input devices ?

I remeber first seeing a Spaceball (2003) on a sgi workstation about 10+
year ago.  Recently I have found then reasonably priced on ebay and
decided to see if I could use them under Linux.  However my initial
attempts meet with little succes.  I used Vojtech Pavlik input layer
driver, along with his inputattach program.  

If you have a spaceball, I would be interested in your experience using
the input layer driver / or how you used it with linux.  Could you send
me then make/model information. Also if you know the firmware string
would be helpful.

The four spaceball I have are 

1) hp A4360A. This is a spaceball 2003b ? model, which has 9 button, the
8 on the top and one on the spaceball itself.  I found this bombed out
of inputtach right away, not even getting by the first
spaceball_waitchar.

2) IBM 6094-030. This is a spaceball 2003c.  Inputattach worked.
detecting, it correctly.

3) Spaceball 3003.  From Spactec itself.  Inputattach found the
spaceball but it failed when the "spaceball_cmd(fd, "hm", r)", command
was issued. It did not recognized this command at.

4) Spaceball 4000 Flx. This failed on the first spaceball_waitchar as
did the hp A4360A.

After several weeks of playing with them under windows with using serial
monitoring, and several test program under linux, I was able to hack
inputtach to workdwith all of them.  I did this by supplying an
additional command line paramater -sb2003b, -sb3003, -sb4000.  I am
including my hacked version of inputattach.c along with slightly tweeked
spaceball.c.  Spaceball.c did not did map the hp A4360A button on the
spaceball itself. Also it sent and the advanced button information for
the spaceball 4000 which was redundant.

Normally the comamnd line is

inputattach --spaceball /dev/ttyS0

to this add -sb2003b, -sb2003c, -sb3003 or -sb4000

ex inputattach --spaceball /dev/ttyS0 -sb2003b


/*
 * $Id: inputattach.c,v 1.21 2002/07/10 22:34:01 vojtech Exp $
 *
 *  Copyright (c) 1999-2000 Vojtech Pavlik
 *
 *  Sponsored by SuSE
 *
 *  Twiddler support Copyright (c) 2001 Arndt Schoenewald
 *  Sponsored by Quelltext AG (http://www.quelltext-ag.de), Dortmund,
Germany
 */

/*
 * Input line discipline attach program
 */

/*
 * This program 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 of the License, or 
 * (at your option) any later version.
 * 
 * This program 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA
 * 
 * Should you need to contact me, the author, you can do so either by
 * e-mail - mail your message to <vo...@uc...>, or by paper mail:
 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
 *
 *  Hack a bit by Allen Lorenz. 
 */

#include <linux/serio.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/time.h>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>

int readchar(int fd, unsigned char *c, int timeout)
{
	struct timeval tv;
	fd_set set;
	
	tv.tv_sec = 0;
	tv.tv_usec = timeout * 1000;

	FD_ZERO(&set);
	FD_SET(fd, &set);

	if (!select(fd+1, &set, NULL, NULL, &tv)) return -1;
	if (read(fd, c, 1) != 1) return -1;

	return 0;
}



void setline(int fd, int flags, int speed)
{
	struct termios t;

	tcgetattr(fd, &t);

	t.c_cflag = flags | CREAD | HUPCL | CLOCAL;
	t.c_iflag = IGNBRK | IGNPAR;
	t.c_oflag = 0;
	t.c_lflag = 0;
	t.c_cc[VMIN ] = 1;
	t.c_cc[VTIME] = 0;

	cfsetispeed(&t, speed);
	cfsetospeed(&t, speed);

	tcsetattr(fd, TCSANOW, &t);
}

int logitech_command(int fd, char *c)
{
	int i;
	unsigned char d;
	for (i = 0; c[i]; i++) {
		write(fd, c + i, 1);
		if (readchar(fd, &d, 1000))
			return -1;
		if (c[i] != d)
			return -1;
	}
	return 0;
}

int magellan_init(int fd, long *id, long *extra)
{
	write(fd, "m3\rpBB\rz\r", 9);
	return 0;
}

int warrior_init(int fd, long *id, long *extra)
{
	if (logitech_command(fd, "*S")) return -1;
	setline(fd, CS8, B4800);
	return 0;
}

int spaceball_waitchar(int fd, unsigned char c, unsigned char *d, int
timeout)
{
	unsigned char b = 0;

	while (!readchar(fd, &b, timeout)) {
		if (b == 0x0a) continue;
		*d++ = b;
		if (b == c) break;
	}

	*d = 0;

	return -(b != c);
}

int spaceball_waitcmd(int fd, char c, char *d)
{
	int i;

	for (i = 0; i < 8; i++) {
		if (spaceball_waitchar(fd, 0x0d, d, 1000))
			return -1;
		if (d[0] == c)
			return 0;
	}

	return -1;
}

int spaceball_cmd(int fd, char *c, char *d)
{
	int i;

	for (i = 0; c[i]; i++)
		write(fd, c + i, 1);
	write(fd, "\r", 1);

	i = spaceball_waitcmd(fd, toupper(c[0]), d);

	return i;
}

#define SPACEBALL_1003		1
#define SPACEBALL_2003A		2
#define SPACEBALL_2003B		3
#define SPACEBALL_2003C		4
#define SPACEBALL_3003C		7
#define SPACEBALL_4000FLX	8
#define SPACEBALL_4000FLX_L 	9


//--- flags for optional arguements
#define SB_2003a  0x0001
#define SB_2003b  0x0002
#define SB_2003c  0x0004
#define SB_3003   0x0008
#define SB_4000   0x0010
#define SB_MASK  ( SB_2003a | SB_2003b | SB_2003c | SB_3003 | SB_4000 )
#define DAEMON    0x8000

typedef struct
{
  char     *string;
  unsigned flag;
} Flag_entry;
Flag_entry flag_table[] =
{
  { "-sb2003a", SB_2003a },
  { "-sb2003b", SB_2003b },
  { "-sb2003c", SB_2003c },
  { "-sb3003",  SB_3003 },
  { "-sb4000",  SB_4000 },
  { "-daemon",  DAEMON },
};
#define NUM_FLAGS 6

char *spaceball_initstring1 = "CB\015FT?\015FR?\015P@r@r\015MSSV\015Z";
char *spaceball_initstring2 = "M\015YC\015\"";

int flags;
int spaceball_init(int fd, long *id, long *extra)
{
	char r[64];

        if (flags & SB_MASK)
        {
           if ( flags & SB_2003a )
           {
             spaceball_cmd( fd, spaceball_initstring1, r );
             spaceball_cmd( fd, spaceball_initstring1, r );
             *id = SPACEBALL_2003A;
           }
           if ( flags & SB_2003b )
           {
             spaceball_cmd( fd, spaceball_initstring1, r );
             spaceball_cmd( fd, spaceball_initstring1, r );
             *id = SPACEBALL_2003B;
           }
           if ( flags & SB_2003c )
           {
             spaceball_cmd( fd, spaceball_initstring1, r );
             spaceball_cmd( fd, spaceball_initstring1, r );
             *id = SPACEBALL_2003C;
           }
           if ( flags & SB_3003 )
           {
             spaceball_cmd( fd, spaceball_initstring1, r );
             spaceball_cmd( fd, spaceball_initstring1, r );
             *id = SPACEBALL_3003C;
           }
           if ( flags & SB_4000 )
           {
             spaceball_cmd( fd, spaceball_initstring2, r );
             spaceball_cmd( fd, spaceball_initstring2, r );
             *id = SPACEBALL_4000FLX;
           }
           
           return(0);
        }

	if (spaceball_waitchar(fd, 0x11, r, 4000) ||
	    spaceball_waitchar(fd, 0x0d, r, 1000))
		return -1;

	if (spaceball_waitcmd(fd, '@', r))
		return -1; 

	if (strncmp("@1 Spaceball alive", r, 18))
		return -1;

	if (spaceball_waitcmd(fd, '@', r))
		return -1; 

	if (spaceball_cmd(fd, "hm", r))
		return -1;

	if (!strncmp("Hm2003B", r, 7))
		*id = SPACEBALL_2003B;
	if (!strncmp("Hm2003C", r, 7))
		*id = SPACEBALL_2003C;
	if (!strncmp("Hm3003C", r, 7))
		*id = SPACEBALL_3003C;

	if (!strncmp("HvFirmware", r, 10)) {

		if (spaceball_cmd(fd, "\"", r))
			return -1;

		if (strncmp("\"1 Spaceball 4000 FLX", r, 21))
			return -1;

		if (spaceball_waitcmd(fd, '"', r))
			return -1; 

		if (strstr(r, " L "))
			*id = SPACEBALL_4000FLX_L;
		else
			*id = SPACEBALL_4000FLX;

		if (spaceball_waitcmd(fd, '"', r))
			return -1; 

		if (spaceball_cmd(fd, "YS", r))
        	        return -1;

		if (spaceball_cmd(fd, "M", r))
        	        return -1;

		return 0;
	}

	if (spaceball_cmd(fd, "P@A@A", r) ||
	    spaceball_cmd(fd, "FT@", r)   ||
	    spaceball_cmd(fd, "MSS", r))
		return -1;

	return 0;
}

int stinger_init(int fd, long *id, long *extra)
{
	int i;
	unsigned char c;
	unsigned char *response = "\r\n0600520058C272";

	if (write(fd, " E5E5", 5) != 5)		/* Enable command */
		return -1; 

	for (i = 0; i < 16; i++)		/* Check for Stinger */
		if (readchar(fd, &c, 200) || (c != response[i])) 
			return -1;

	return 0;
}

int mzp_init(int fd, long *id, long *extra)
{
	if (logitech_command(fd, "*X*q")) return -1;
	setline(fd, CS8, B9600);
	return 0;
}

int newton_init(int fd, long *id, long *extra)
{
  int i;
  unsigned char c;
  unsigned char response[35] =
  { 0x16, 0x10, 0x02, 0x64, 0x5f, 0x69, 0x64, 0x00,
    0x00, 0x00, 0x0c, 0x6b, 0x79, 0x62, 0x64, 0x61,
    0x70, 0x70, 0x6c, 0x00, 0x00, 0x00, 0x01, 0x6e,
    0x6f, 0x66, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x10,
    0x03, 0xdd, 0xe7 };

  for (i = 0; i < 35; i++)
    if (readchar(fd, &c, 400) || (c != response[i]))
      return -1;

  return 0;
}

int twiddler_init(int fd, long *id, long *extra)
{
	unsigned char c[10];
	int count, line;

	/* Turn DTR off, otherwise the Twiddler won't send any data. */
	if (ioctl(fd, TIOCMGET, &line)) return -1;
	line &= ~TIOCM_DTR;
	if (ioctl(fd, TIOCMSET, &line)) return -1;

	/* Check whether the device on the serial line is the Twiddler.
	 *
	 * The Twiddler sends data packets of 5 bytes which have the following
	 * properties: the MSB is 0 on the first and 1 on all other bytes, and
	 * the high order nibble of the last byte is always 0x8.
	 *
	 * We read and check two of those 5 byte packets to be sure that we
	 * are indeed talking to a Twiddler. */

	/* Read at most 5 bytes until we find one with the MSB set to 0 */
	for (count = 0; count < 5; count++) {
		if (readchar(fd, c+0, 500)) return -1;
		if ((c[0] & 0x80) == 0) break;
	}

	if (count == 5) {
		/* Could not find header byte in data stream */
		return -1;
	}

	/* Read remaining 4 bytes plus the full next data packet */
	for (count = 1; count < 10; count++) {
		if (readchar(fd, c+count, 500)) return -1;
	}

	/* Check whether the bytes of both data packets obey the rules */
	for (count = 1; count < 10; count++) {
		if ((count % 5 == 0 && (c[count] & 0x80) != 0)
		    || (count % 5 == 4 && (c[count] & 0xF0) != 0x80)
		    || (count % 5 != 0 && (c[count] & 0x80) != 0x80)) {
		    	/* Invalid byte in data packet */
			return -1;
		}
	}

	return 0;
}

int dump_init(int fd, long *id, long *extra)
{
	unsigned char c, o = 0;

	c = 0x80;

	if (write(fd, &c, 1) != 1)         /* Enable command */
                return -1;

	while (1)
		if (!readchar(fd, &c, 1)) {
			printf("%02x (%c) ", c, ((c > 32) && (c < 127)) ? c : 'x');
			o = 1;
		} else {
			if (o) {
				printf("\n");
				o = 0;
			}
		}
}

struct input_types {
	char name[16];
	char name2[16];
	int speed;
	int flags;
	unsigned long type;
	unsigned long extra;
	int flush;
	int (*init)(int fd, long *id, long *extra);
};

struct input_types input_types[] = {

{ "--sunkbd",		"-skb",		B1200, CS8,			SERIO_SUNKBD,	0x00,	1,	NULL },
{ "--spaceorb",		"-orb",		B9600, CS8,			SERIO_SPACEORB,	0x00,	1,	NULL },
{ "--spaceball",	"-sbl",		B9600,
CS8,			SERIO_SPACEBALL,0x00,	0,	spaceball_init },
{ "--magellan",		"-mag",		B9600, CS8 | CSTOPB |
CRTSCTS,	SERIO_MAGELLAN,	0x00,	1,	magellan_init },
{ "--warrior",		"-war",		B1200, CS7 |
CSTOPB,		SERIO_WARRIOR,	0x00,	1,	warrior_init },
{ "--stinger",		"-sting",	B1200,
CS8,			SERIO_STINGER,	0x00,	1,	stinger_init },
{ "--mousesystems",	"-msc",		B1200, CS8,			SERIO_MSC,	0x01,	1,	NULL },
{ "--sunmouse",		"-sun",		B1200, CS8,			SERIO_SUN,	0x01,	1,	NULL },
{ "--microsoft",	"-bare",	B1200, CS7,			SERIO_MS,	0x00,	1,	NULL },
{ "--mshack",		"-ms",		B1200, CS7,			SERIO_MS,	0x01,	1,	NULL },
{ "--mouseman",		"-mman",	B1200, CS7,			SERIO_MP,	0x01,	1,	NULL },
{ "--intellimouse",	"-ms3",		B1200, CS7,			SERIO_MZ,	0x11,	1,	NULL },
{ "--mmwheel",		"-mmw",		B1200, CS7 |
CSTOPB,		SERIO_MZP,	0x13,	1,	mzp_init },
{ "--iforce",		"-ifor",	B38400, CS8,			SERIO_IFORCE,	0x00,	0,	NULL },
{ "--newtonkbd",        "-newt",        B9600, CS8,                    
SERIO_NEWTON,	0x00,   0,      newton_init },
{ "--h3600ts",          "-ipaq",     	B115200, CS8,                  
SERIO_H3600,	0x00,   0,      NULL },
{ "--stowawaykbd",      "-ipaqkbd",     B115200, CS8,                  
SERIO_STOWAWAY, 0x00,   0,      NULL },
{ "--ps2serkbd",	"-ps2ser",	B1200, CS8,			SERIO_PS2SER,	0x00,	1,	NULL },
#if 0
{ "--twiddler",		"-twid",	B2400,
CS8,			SERIO_TWIDKBD,	0x00,	0,	twiddler_init },
{ "--twiddler-joy",	"-twidjoy",	B2400,
CS8,			SERIO_TWIDJOY,	0x00,	0,	twiddler_init },
{ "--ipod-remote",	"-ipod",	B9600, CS8,			SERIO_IPOD_REM,	0x00,	0,	NULL
},
#endif
{ "--dump",		"-dump",	B2400, CS8, 			0,		0x00,	0,	dump_init },
{ "", "", 0, 0 }

};

int main(int argc, char **argv)
{
	unsigned long devt;
	int ldisc;
        int type;
	long id, extra;
        int fd;
	char c;
        int  i,j;

        if ((argc < 2 ) || !strcmp("--help", argv[1])) {
                puts("");
                puts("Usage: inputttach <mode> <device>");
                puts("");
                puts("Modes:");
                puts("  --sunkbd        -skb   Sun Type 4 and Type 5
keyboards");
                puts("  --spaceorb      -orb   SpaceOrb 360 / SpaceBall
Avenger");
		puts("  --spaceball     -sbl   SpaceBall 2003 / 3003 / 4000 FLX");
                puts("  --magellan      -mag   Magellan / SpaceMouse");
                puts("  --warrior       -war   WingMan Warrior");
		puts("  --stinger       -stng  Gravis Stinger");
		puts("  --mousesystems  -msc   3-button Mouse Systems mice");
		puts("  --sunmouse      -sun   3-button Sun mice");
		puts("  --microsoft     -bare  2-button Microsoft mice");
		puts("  --mshack        -ms    3-button mice in Microsoft mode");
		puts("  --mouseman      -mman  3-button Logitech and Genius mice");
		puts("  --intellimouse  -ms3   Microsoft IntelliMouse");
		puts("  --mmwheel       -mmw   Logitech mice with 4-5 buttons or
wheel");
		puts("  --iforce        -ifor  I-Force joysticks and wheels");
                puts("  --h3600ts       -ipaq  Ipaq h3600 touchscreen");
		puts("  --stowawaykbd   -ipaqkbd  Stowaway keyboard");
		puts("  --ps2serkbd     -ps2ser PS/2 via serial keyboard");
#if 0
		puts("  --twiddler      -twid   Handykey Twiddler chording keyboard");
		puts("  --twiddler-joy  -twidjoy  Handykey Twiddler used as a
joystick");
		puts("  --ipod-remote   -ipod  iPod remote control");
#endif
		puts("");
                return 1;
        }

        if ( argc > 3 )
        {
          flags = 0;
          for( i = 3; i < argc; i++ )
          {
            for( j = 0; j < NUM_FLAGS; j++ )
            {
               if ( strcmp( flag_table[j].string, argv[i] ) == 0 )
                 flags |= flag_table[j].flag;
            }
          }
        }

        for (type = 0; input_types[type].speed; type++) {
                if (!strncasecmp(argv[1], input_types[type].name, 16) ||
			!strncasecmp(argv[1], input_types[type].name2, 16))
                        break;
        }

	if (!input_types[type].speed) {
		fprintf(stderr, "inputattach: invalid mode\n");
		return 1;
	}

	if ((fd = open(argv[2], O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0) {
		perror("inputattach");
		return 1;
	}

	setline(fd, input_types[type].flags, input_types[type].speed);

	if (input_types[type].flush)
		while (!readchar(fd, &c, 100));

	id = 0;
	extra = input_types[type].extra;

	if (input_types[type].init && input_types[type].init(fd, &id, &extra))
{
		fprintf(stderr, "inputattach: device initialization failed\n");
		return 1;
	}

	ldisc = N_MOUSE;
	if(ioctl(fd, TIOCSETD, &ldisc)) {
		fprintf(stderr, "inputattach: can't set line discipline\n"); 
		return 1;
	}

	devt = SERIO_RS232 | input_types[type].type | (id << 8) | (extra <<
16);

	if(ioctl(fd, SPIOCSTYPE, &devt)) {
		fprintf(stderr, "inputattach: can't set device type\n");
		return 1;
	}
	
	if ( flags & DAEMON )
		daemon(0,0);

	read(fd, NULL, 0);

	ldisc = 0;
	ioctl(fd, TIOCSETD, &ldisc);
	close(fd);

	return 0;
}




/*
 * $Id: spaceball.c,v 1.17 2002/01/22 20:29:03 vojtech Exp $
 *
 *  Copyright (c) 1999-2001 Vojtech Pavlik
 *
 *  Based on the work of:
 *  	David Thompson
 *  	Joseph Krahn
 */

/*
 * SpaceTec SpaceBall 2003/3003/4000 FLX driver for Linux
 */

/*
 * This program 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 of the License, or 
 * (at your option) any later version.
 * 
 * This program 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA
 * 
 *  Should you need to contact me, the author, you can do so either by
 * e-mail - mail your message to <vo...@uc...>, or by paper mail:
 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
 *
 * hacked a bit by Allen Lorenz
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/serio.h>

MODULE_AUTHOR("Vojtech Pavlik <vo...@uc...>");
MODULE_DESCRIPTION("SpaceTec SpaceBall 2003/3003/4000 FLX driver");
MODULE_LICENSE("GPL");

/*
 * Constants.
 */

#define SPACEBALL_MAX_LENGTH	128
#define SPACEBALL_MAX_ID	8

#define SPACEBALL_1003      1
#define SPACEBALL_2003B     3
#define SPACEBALL_2003C     4
#define SPACEBALL_3003C     7
#define SPACEBALL_4000FLX   8
#define SPACEBALL_4000FLX_L 9

static int spaceball_axes[] = { ABS_X, ABS_Z, ABS_Y, ABS_RX, ABS_RZ,
ABS_RY };
static char *spaceball_names[] = {
	"?", "SpaceTec SpaceBall 1003", "SpaceTec SpaceBall 2003", "SpaceTec
SpaceBall 2003B", 
	"SpaceTec SpaceBall 2003C", "SpaceTec SpaceBall 3003", "SpaceTec
SpaceBall SpaceController", 
	"SpaceTec SpaceBall 3003C", "SpaceTec SpaceBall 4000FLX", "SpaceTec
SpaceBall 4000FLX Lefty" };

/*
 * Per-Ball data.
 */

struct spaceball {
	struct input_dev dev;
	struct serio *serio;
	int idx;
	int escape;
	unsigned char data[SPACEBALL_MAX_LENGTH];
	char phys[32];
};

/*
 * spaceball_process_packet() decodes packets the driver receives from
the
 * SpaceBall.
 */

static void spaceball_process_packet(struct spaceball* spaceball, struct
pt_regs *regs)
{
	struct input_dev *dev = &spaceball->dev;
	unsigned char *data = spaceball->data;
	int i;

	if (spaceball->idx < 2) return;

	input_regs(dev, regs);

	switch (spaceball->data[0]) {

		case 'D':					/* Ball data */
			if (spaceball->idx != 15) return;
			for (i = 0; i < 6; i++)
				input_report_abs(dev, spaceball_axes[i], 
					(__s16)((data[2 * i + 3] << 8) | data[2 * i + 2]));
			break;

		case 'K':					/* Button data */
			if (spaceball->idx != 3) return;
                        if (dev->id.product > 7 ) return;  /* advance
button data follows */ 
			input_report_key(dev, BTN_1, (data[2] & 0x01) || (data[2] & 0x20));
			input_report_key(dev, BTN_2, data[2] & 0x02);
			input_report_key(dev, BTN_3, data[2] & 0x04);
			input_report_key(dev, BTN_4, data[2] & 0x08);
			input_report_key(dev, BTN_5, data[1] & 0x01);
			input_report_key(dev, BTN_6, data[1] & 0x02);
			input_report_key(dev, BTN_7, data[1] & 0x04);
			input_report_key(dev, BTN_9, data[1] & 0x08);
			input_report_key(dev, BTN_8, data[1] & 0x10);
			break;

		case '.':					/* Advanced button data */
			if (spaceball->idx != 3) return;
			input_report_key(dev, BTN_A, data[2] & 0x01);
			input_report_key(dev, BTN_B, data[2] & 0x02);
			input_report_key(dev, BTN_C, data[2] & 0x04);
			input_report_key(dev, BTN_1, data[2] & 0x08);
			input_report_key(dev, BTN_2, data[2] & 0x10);
			input_report_key(dev, BTN_3, data[2] & 0x20);
			input_report_key(dev, BTN_4, data[2] & 0x80);
			input_report_key(dev, BTN_5, data[1] & 0x01);
			input_report_key(dev, BTN_6, data[1] & 0x02);
			input_report_key(dev, BTN_7, data[1] & 0x04);
			input_report_key(dev, BTN_8, data[1] & 0x08);
			input_report_key(dev, BTN_9, data[1] & 0x10);
			break;

		case 'E':					/* Device error */
			spaceball->data[spaceball->idx - 1] = 0;
			printk(KERN_ERR "spaceball: Device error. [%s]\n", spaceball->data +
1);
			break;

		case '?':					/* Bad command packet */
			spaceball->data[spaceball->idx - 1] = 0;
			printk(KERN_ERR "spaceball: Bad command. [%s]\n", spaceball->data +
1);
			break;
	}

	input_sync(dev);
}

/*
 * Spaceball 4000 FLX packets all start with a one letter packet-type
decriptor,
 * and end in 0x0d. It uses '^' as an escape for CR, XOFF and XON
characters which
 * can occur in the axis values.
 */

static irqreturn_t spaceball_interrupt(struct serio *serio,
		unsigned char data, unsigned int flags, struct pt_regs *regs)
{
	struct spaceball *spaceball = serio->private;

	switch (data) {
		case 0xd:
			spaceball_process_packet(spaceball, regs);
			spaceball->idx = 0;
			spaceball->escape = 0;
			break;
		case '^':
			if (!spaceball->escape) {
				spaceball->escape = 1;
				break;
			}
			spaceball->escape = 0;
		case 'M':
		case 'Q':
		case 'S':
			if (spaceball->escape) {
				spaceball->escape = 0;
				data &= 0x1f;
			}
		default:
			if (spaceball->escape)
				spaceball->escape = 0;
			if (spaceball->idx < SPACEBALL_MAX_LENGTH)
				spaceball->data[spaceball->idx++] = data;
			break;
	}
	return IRQ_HANDLED;
}

/*
 * spaceball_disconnect() is the opposite of spaceball_connect()
 */

static void spaceball_disconnect(struct serio *serio)
{
	struct spaceball* spaceball = serio->private;
	input_unregister_device(&spaceball->dev);
	serio_close(serio);
	kfree(spaceball);
}

/*
 * spaceball_connect() is the routine that is called when someone adds a
 * new serio device. It looks for the Magellan, and if found, registers
 * it as an input device.
 */

static void spaceball_connect(struct serio *serio, struct serio_dev
*dev)
{
	struct spaceball *spaceball;
	int i, t, id;

	if ((serio->type & ~SERIO_ID) != (SERIO_RS232 | SERIO_SPACEBALL))
		return;

	if ((id = (serio->type & SERIO_ID) >> 8) > SPACEBALL_MAX_ID)
		return;

	if (!(spaceball = kmalloc(sizeof(struct spaceball), GFP_KERNEL)))
		return;
	memset(spaceball, 0, sizeof(struct spaceball));

	spaceball->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);	

	switch (id) {
		case SPACEBALL_4000FLX:
		case SPACEBALL_4000FLX_L:
			spaceball->dev.keybit[LONG(BTN_A)] |= BIT(BTN_A) | BIT(BTN_B) |
BIT(BTN_C);
		case SPACEBALL_2003B:
			spaceball->dev.keybit[LONG(BTN_0)] |= BIT(BTN_9);
		default:
			spaceball->dev.keybit[LONG(BTN_0)] |= BIT(BTN_2) | BIT(BTN_3) |
BIT(BTN_4) 
				| BIT(BTN_5) | BIT(BTN_6) | BIT(BTN_7) | BIT(BTN_8);
		case SPACEBALL_3003C:
			spaceball->dev.keybit[LONG(BTN_0)] |= BIT(BTN_1) | BIT(BTN_8);
	}

	for (i = 0; i < 6; i++) {
		t = spaceball_axes[i];
		set_bit(t, spaceball->dev.absbit);
		spaceball->dev.absmin[t] = i < 3 ? -8000 : -1600;
		spaceball->dev.absmax[t] = i < 3 ?  8000 :  1600;
		spaceball->dev.absflat[t] = i < 3 ? 40 : 8;
		spaceball->dev.absfuzz[t] = i < 3 ? 8 : 2;
	}

	spaceball->serio = serio;
	spaceball->dev.private = spaceball;

	sprintf(spaceball->phys, "%s/input0", serio->phys);

	init_input_dev(&spaceball->dev);
	spaceball->dev.name = spaceball_names[id];
	spaceball->dev.phys = spaceball->phys;
	spaceball->dev.id.bustype = BUS_RS232;
	spaceball->dev.id.vendor = SERIO_SPACEBALL;
	spaceball->dev.id.product = id;
	spaceball->dev.id.version = 0x0100;
	
	serio->private = spaceball;

	if (serio_open(serio, dev)) {
		kfree(spaceball);
		return;
	}

	input_register_device(&spaceball->dev);

	printk(KERN_INFO "input: %s on serio%s\n",
		spaceball_names[id], serio->phys);
}

/*
 * The serio device structure.
 */

static struct serio_dev spaceball_dev = {
	.interrupt =	spaceball_interrupt,
	.connect =	spaceball_connect,
	.disconnect =	spaceball_disconnect,
};

/*
 * The functions for inserting/removing us as a module.
 */

int __init spaceball_init(void)
{
	serio_register_device(&spaceball_dev);
	return 0;
}

void __exit spaceball_exit(void)
{
	serio_unregister_device(&spaceball_dev);
}

module_init(spaceball_init);
module_exit(spaceball_exit);