Attachment #31095: xbox-sources-2.6.6-CVS10May2004.patch for bug #45100

config X86_XBOX

	bool "Microsoft Xbox"

	help

	  This option is needed to make Linux boot on XBox Gaming Systems.

	  The XBox can be considered as a standard PC with a Coppermine-based Celeron 733 MHz,

	  IDE harddrive, DVD, Ethernet, USB and graphics.

	  To boot the kernel you need "_romwell", either used as a replacement BIOS (cromwell)

	  or as a bootloader.

	  For more information see http://xbox-linux.sourceforge.net/

	  If you do not specifically need a kernel for XBOX machine,

	  say N here otherwise the kernel you build will not be bootable.

config XBOX_EJECT

	bool "XBOX eject fix"

	depends on X86_XBOX

# Xbox subarch support

mflags-$(CONFIG_X86_XBOX)	:= -Iinclude/asm-i386/mach-xbox

mcore-$(CONFIG_X86_XBOX)	:= mach-xbox

#

# There is some strange interaction when paging is off, that makes

# newer v1.1+ Xboxen (manufactured August 2002 or later) crash while

# decrompressing the kernel. Compiling the decrompressor without any

# optimization reliably works around this problem.

#

ifeq ($(CONFIG_X86_XBOX),y)

CFLAGS_misc.o	:= -O0

endif

obj-$(CONFIG_XBOX_EJECT)        += xboxejectfix.o

/**

 * Driver that handles the EXTSMI# interrupt on the xbox.

 * Makes it possible to use the eject-button without the xbox rebooting...

 *

 * smbus-command sequence to prevent reboot from cromwell.

 *

 * Changelog:

 *  2003-01-14 Anders Gustafsson <andersg@0x63.nu>

 *             initial version

 *  2003-02-08 Milosch Meriac <xboxlinux@meriac.de>

 *             rewrote debug macros because of compiler errors

 *  2003-08-06 Michael Steil <mist@c64.org>

 *             removed Linux I2C dependency, now compiles

 *             without I2C in the kernel

 *

 * Todo: add errorhandling!

 *

 */

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <asm/io.h>

#include <linux/xbox.h>

#include <linux/interrupt.h>

#define IRQ 12

#define DRIVER_NAME "xboxejectfix"

/* just some crap */

static char dev[]=DRIVER_NAME;

/* External variable from ide-cd.c that specifies whether we simulate drive

   locking in software */

extern volatile int Xbox_simulate_drive_locked;

#define BASE 0x8000

/* Power Management 1 Enable Register */

#define PM02 (BASE+0x02)

/* Power Management 1 Control Register */

#define PM04 (BASE+0x04)

/* ACPI GP Status Register */

#define PM20 (BASE+0x20)

/* ACPI GP Enable Register */

#define PM22 (BASE+0x22)

# define EXTSMI_EN_MASK 0x0002

/* Global SMI Enable Register */

#define PM2A (BASE+0x2A)

static DECLARE_MUTEX(extsmi_sem);

static DECLARE_COMPLETION(extsmi_exited);

static int extsmi_pid=0;

static irqreturn_t extsmi_interupt(int unused, void *dev_id, struct pt_regs *regs) {

	int reason;

	reason=inw(0x8020);

	outw(reason,0x8020); /* ack  IS THIS NEEDED? */

	if(reason&0x2){

		/* wake up thread */

		up(&extsmi_sem);

	}

	return 0;

}

/**

 * Process an event. This is run in process-context.

 */

static void extsmi_process(void){

	int reason;

	reason=Xbox_SMC_read(SMC_CMD_INTERRUPT_REASON);

	if(reason&TRAYBUTTON_MASK){ /* Tray button! Respond to prevent reboot! */

		Xbox_SMC_write(SMC_CMD_INTERRUPT_RESPOND, SMC_SUBCMD_RESPOND_CONTINUE);

		Xbox_SMC_write(0x00, 0x0c);

		/* eject unless lock simulation is being used */

		if (!Xbox_simulate_drive_locked)

			Xbox_tray_eject();

	}

}

static int extsmi_thread(void *data){

	daemonize("extsmi");

	reparent_to_init();

	strcpy(current->comm, "xbox_extsmi");

	do {

		extsmi_process();

		down_interruptible(&extsmi_sem);

	} while (!signal_pending(current));

         complete_and_exit(&extsmi_exited, 0);

}

static int extsmi_init(void){

	int pid;

	if (!machine_is_xbox) {

		printk("This machine is no Xbox.\n");

		return -1;

	}

	printk("Enabling Xbox eject problem workaround.\n");

        pid = kernel_thread(extsmi_thread, NULL,

			    CLONE_FS | CLONE_FILES | CLONE_SIGHAND);

	if (pid < 0) {

		return pid;

	}

	extsmi_pid = pid;

	/* this shuts a lot of interrupts off! */

	outw(inw(0x80e2)&0xf8c7,0x80e2);

	outw(0,0x80ac);

	outb(0,0x8025);

	outw(EXTSMI_EN_MASK,PM22); /* enable the EXTSMI# interupt! */

	outw(0,PM02);

	outb(1,PM04); /* enable sci interrupts! */

	Xbox_SMC_write(SMC_CMD_RESET_ON_EJECT, SMC_SUBCMD_RESET_ON_EJECT_DISABLE);

	/* FIXME! retval! */

	request_irq(IRQ,extsmi_interupt,SA_INTERRUPT|SA_SHIRQ,"xboxejectfix",dev);

	return 0;

}

static void extsmi_exit(void){

	int res;

	if (!machine_is_xbox) return; /* can this happen??? */

	free_irq(IRQ,dev);

	/* Kill the thread */

	res = kill_proc(extsmi_pid, SIGTERM, 1);

	wait_for_completion(&extsmi_exited);

	return;

}

module_init(extsmi_init);

module_exit(extsmi_exit);

MODULE_AUTHOR("Anders Gustafsson <andersg@0x63.nu>");

MODULE_LICENSE("GPL");

#

# Makefile for the linux kernel.

#

obj-y				:= setup.o reboot.o

/*

 * arch/i386/mach-xbox/reboot.c 

 * Olivier Fauchon <olivier.fauchon@free.fr>

 * Anders Gustafsson <andersg@0x63.nu>

 *

 */

#include <asm/io.h>

/* we don't use any of those, but dmi_scan.c needs 'em */

void (*pm_power_off)(void);

int reboot_thru_bios;

#define XBOX_SMB_IO_BASE		0xC000

#define XBOX_SMB_HOST_ADDRESS		(0x4 + XBOX_SMB_IO_BASE)

#define XBOX_SMB_HOST_COMMAND		(0x8 + XBOX_SMB_IO_BASE)

#define XBOX_SMB_HOST_DATA		(0x6 + XBOX_SMB_IO_BASE)

#define XBOX_SMB_GLOBAL_ENABLE		(0x2 + XBOX_SMB_IO_BASE)

#define XBOX_PIC_ADDRESS		0x10

#define SMC_CMD_POWER			0x02

#define SMC_SUBCMD_POWER_RESET		0x01

#define SMC_SUBCMD_POWER_CYCLE		0x40

#define SMC_SUBCMD_POWER_OFF		0x80

static void xbox_pic_cmd(u8 command)

{

	outw_p(((XBOX_PIC_ADDRESS) << 1), XBOX_SMB_HOST_ADDRESS);

	outb_p(SMC_CMD_POWER, XBOX_SMB_HOST_COMMAND);

	outw_p(command, XBOX_SMB_HOST_DATA);

	outw_p(inw(XBOX_SMB_IO_BASE), XBOX_SMB_IO_BASE);

	outb_p(0x0a, XBOX_SMB_GLOBAL_ENABLE);

}

void machine_restart(char * __unused)

{

	printk(KERN_INFO "Sending POWER_CYCLE to XBOX-PIC.\n");

	xbox_pic_cmd(SMC_SUBCMD_POWER_CYCLE);  

}

void machine_power_off(void)

{

	printk(KERN_INFO "Sending POWER_OFF to XBOX-PIC.\n");

	xbox_pic_cmd(SMC_SUBCMD_POWER_OFF);  

}

void machine_halt(void)

{

}

/*

 *	Machine specific setup for xbox

 */

#include <linux/config.h>

#include <linux/smp.h>

#include <linux/init.h>

#include <linux/irq.h>

#include <linux/interrupt.h>

#include <asm/arch_hooks.h>

/**

 * pre_intr_init_hook - initialisation prior to setting up interrupt vectors

 *

 * Description:

 *	Perform any necessary interrupt initialisation prior to setting up

 *	the "ordinary" interrupt call gates.  For legacy reasons, the ISA

 *	interrupts should be initialised here if the machine emulates a PC

 *	in any way.

 **/

void __init pre_intr_init_hook(void)

{

	init_ISA_irqs();

}

/*

 * IRQ2 is cascade interrupt to second interrupt controller

 */

static struct irqaction irq2 = { no_action, 0, 0, "cascade", NULL, NULL };

/**

 * intr_init_hook - post gate setup interrupt initialisation

 *

 * Description:

 *	Fill in any interrupts that may have been left out by the general

 *	init_IRQ() routine.  interrupts having to do with the machine rather

 *	than the devices on the I/O bus (like APIC interrupts in intel MP

 *	systems) are started here.

 **/

void __init intr_init_hook(void)

{

#ifdef CONFIG_X86_LOCAL_APIC

	apic_intr_init();

#endif

	setup_irq(2, &irq2);

}

/**

 * pre_setup_arch_hook - hook called prior to any setup_arch() execution

 *

 * Description:

 *	generally used to activate any machine specific identification

 *	routines that may be needed before setup_arch() runs.  On VISWS

 *	this is used to get the board revision and type.

 **/

void __init pre_setup_arch_hook(void)

{

}

/**

 * trap_init_hook - initialise system specific traps

 *

 * Description:

 *	Called as the final act of trap_init().  Used in VISWS to initialise

 *	the various board specific APIC traps.

 **/

void __init trap_init_hook(void)

{

}

static struct irqaction irq0  = { timer_interrupt, SA_INTERRUPT, 0, "timer", NULL, NULL };

/**

 * time_init_hook - do any specific initialisations for the system timer.

 *

 * Description:

 *	Must plug the system timer interrupt source at HZ into the IRQ listed

 *	in irq_vectors.h:TIMER_IRQ

 **/

void __init time_init_hook(void)

{

	setup_irq(0, &irq0);

}

#include "mach_pci_blacklist.h"

	if (mach_pci_is_blacklisted(bus, PCI_SLOT(devfn), PCI_FUNC(devfn)))

		return -EINVAL;

config I2C_XBOX

	tristate "XBOX I2C"

	depends on I2C && EXPERIMENTAL

obj-$(CONFIG_I2C_XBOX)		+= i2c-xbox.o

/*

    i2c-xbox.c - Part of lm_sensors, Linux kernel modules for hardware

              monitoring

    Copyright (c) 1999-2002 Edgar Hucek <hostmaster@ed-soft.at>

    Shamelessly ripped from i2c-xbox.c:

    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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

/*

   Supports XBOX, Note: we assume there can only be one device, with one SMBus interface.

*/

#include <linux/version.h>

#include <linux/module.h>

#include <linux/pci.h>

#include <asm/io.h>

#include <linux/kernel.h>

#include <linux/stddef.h>

#include <linux/sched.h>

#include <linux/ioport.h>

#include <linux/i2c.h>

#include <linux/init.h>

#include <linux/sched.h>

#include <linux/errno.h>  /* error codes */

#include <linux/interrupt.h> /* intr_count */

#include <linux/xbox.h>

#include <linux/delay.h>

#define GS_ABRT_STS (1 << 0)

#define GS_COL_STS (1 << 1)

#define GS_PRERR_STS (1 << 2)

#define GS_HST_STS (1 << 3)

#define GS_IRQ_ON (1 << 4)

#define GS_HCYC_STS (1 << 4)

#define GS_TO_STS (1 << 5)

#define GS_SMB_STS (1 << 11)

#define SMB_GCTL_HOST_START      (1 << 3)

#define SMB_GCTL_HOST_INTERRUPT  (1 << 4)

#define SMB_GCTL_ABORT           (1 << 5)

#define SMB_GCTL_SNOOP           (1 << 8)

#define SMB_GCTL_SLAVE_INTERRUPT (1 << 9)

#define SMB_GCTL_ALERT_INTERRUPT (1 << 10)

#define GS_CLEAR_STS (GS_ABRT_STS | GS_COL_STS | GS_PRERR_STS | \

  GS_HCYC_STS | GS_TO_STS)

#define GE_CYC_TYPE_MASK (7)

#define GE_HOST_STC (1 << 3)

#define GE_ABORT (1 << 5)

#define I2C_HW_SMBUS_XBOX   0x05

#define SMBGCFG   0x041          /* mh */

#define SMBBA     0x058           /* mh */

struct sd {

    const unsigned short vendor;

    const unsigned short device;

    const unsigned short function;

    const char* name;

    int amdsetup:1;

};

static struct sd supported[] = {

    {PCI_VENDOR_ID_NVIDIA, 0x01b4, 1, "nVidia XBOX nForce", 0},

    {0, 0, 0}

};

/* XBOX SMBus address offsets */

#define SMB_ADDR_OFFSET        0x04

#define SMB_IOSIZE             8

#define SMB_GLOBAL_STATUS      (0x0 + xbox_smba)

#define SMB_GLOBAL_ENABLE      (0x2 + xbox_smba)

#define SMB_HOST_ADDRESS       (0x4 + xbox_smba)

#define SMB_HOST_DATA          (0x6 + xbox_smba)

#define SMB_HOST_COMMAND       (0x8 + xbox_smba)

/* Other settings */

#define MAX_TIMEOUT 500

/* XBOX constants */

#define XBOX_QUICK        0x00

#define XBOX_BYTE         0x01

#define XBOX_BYTE_DATA    0x02

#define XBOX_WORD_DATA    0x03

#define XBOX_PROCESS_CALL 0x04

#define XBOX_BLOCK_DATA   0x05

/* insmod parameters */

#ifdef MODULE

static

#else

extern

#endif

int __init i2c_xbox_init(void);

static int __init xbox_cleanup(void);

static int xbox_setup(void);

static s32 xbox_access(struct i2c_adapter *adap, u16 addr,

			 unsigned short flags, char read_write,

			 u8 command, int size, union i2c_smbus_data *data);

static void xbox_do_pause(unsigned int amount);

static void xbox_abort(void);

static int xbox_transaction(void);

static u32 xbox_func(struct i2c_adapter *adapter);

static struct i2c_algorithm smbus_algorithm = {

	/* name */ "Non-I2C SMBus adapter",

	/* id */ I2C_ALGO_SMBUS,

	/* master_xfer */ NULL,

	/* smbus_access */ xbox_access,

	/* slave;_send */ NULL,

	/* slave_rcv */ NULL,

	/* algo_control */ NULL,

	/* functionality */ xbox_func,

};

static struct i2c_adapter xbox_adapter = {

	.owner          = THIS_MODULE,

	.class          = I2C_ADAP_CLASS_SMBUS,

	.algo           = &smbus_algorithm,

	.name           = "unset",

};

static int __initdata xbox_initialized;

static unsigned short xbox_smba = 0;

spinlock_t xbox_driver_lock = SPIN_LOCK_UNLOCKED;

struct driver_data;

static struct pci_dev *XBOX_dev;

/* Detect whether a XBOX can be found, and initialize it, where necessary.

   Note the differences between kernels with the old PCI BIOS interface and

   newer kernels with the real PCI interface. In compat.h some things are

   defined to make the transition easier. */

int xbox_setup(void)

{

	unsigned char temp;

	struct sd *currdev;

	u16 cmd;

	XBOX_dev = NULL;

	/* Look for a supported chip */

	for(currdev = supported; currdev->vendor; ) {

		XBOX_dev = pci_find_device(currdev->vendor,

						currdev->device, XBOX_dev);

		if (XBOX_dev != NULL)	{

	                pci_read_config_byte(XBOX_dev, SMBGCFG, &temp);

			pci_read_config_word(XBOX_dev, 0x14, &xbox_smba);

			xbox_smba &= 0xfffc;

			if (PCI_FUNC(XBOX_dev->devfn) == currdev->function)

			{

				pci_read_config_word(XBOX_dev,PCI_STATUS,&cmd);

				break;

			}

		} else {

		    currdev++;

		}

	}

	if (XBOX_dev == NULL) {

		printk

		    ("i2c-xbox.o: Error: No XBOX or compatible device detected!\n");

		return(-ENODEV);

	}

	printk(KERN_INFO "i2c-xbox.o: Found %s SMBus controller.\n", currdev->name);

	/* Everything is happy, let's grab the memory and set things up. */

	if(!request_region(xbox_smba, SMB_IOSIZE, "xbox-smbus")) {

		printk

		    ("i2c-xbox.o: SMB region 0x%x already in use!\n",

		     xbox_smba);

		return(-ENODEV);

	}

	return 0;

}

/* 

  SMBUS event = I/O 28-29 bit 11

     see E0 for the status bits and enabled in E2

*/

/* Internally used pause function */

void xbox_do_pause(unsigned int amount)

{

	current->state = TASK_INTERRUPTIBLE;

	schedule_timeout(amount);

}

void xbox_abort(void)

{

	printk("i2c-xbox.o: Sending abort.\n");

	outw_p(inw(SMB_GLOBAL_ENABLE) | GE_ABORT, SMB_GLOBAL_ENABLE);

	xbox_do_pause(100);

	outw_p(GS_CLEAR_STS, SMB_GLOBAL_STATUS);

}

int xbox_transaction(void)

{

	int temp;

	int result = 0;

	int timeout = 0;

	/* Make sure the SMBus host is ready to start transmitting */

	if ((temp = inw_p(SMB_GLOBAL_STATUS)) & (GS_HST_STS | GS_SMB_STS)) {

		do {

			udelay(100);

			temp = inw_p(SMB_GLOBAL_STATUS);

		} while ((temp & (GS_HST_STS | GS_SMB_STS)) &&

		         (timeout++ < MAX_TIMEOUT));

		/* If the SMBus is still busy, we give up */

		if (timeout >= MAX_TIMEOUT) {

			printk("i2c-xbox.o: Busy wait timeout! (%04x)\n", temp);

			xbox_abort();

			return(-1);

		}

		timeout = 0;

	}

	/* start the transaction by setting the start bit */

	outw_p(inw(SMB_GLOBAL_ENABLE) | GE_HOST_STC , SMB_GLOBAL_ENABLE);

	/* We will always wait for a fraction of a second! */

	temp = inw_p(SMB_GLOBAL_STATUS);

	while ((temp & GS_HST_STS) && (timeout++ < MAX_TIMEOUT)) {

		udelay(100);

		temp = inw_p(SMB_GLOBAL_STATUS);		

	} 

	/* If the SMBus is still busy, we give up */

	if (timeout >= MAX_TIMEOUT) {

		printk("i2c-xbox.o: Completion timeout!\n");

		xbox_abort ();

		return(-1);

	}

	if (temp & GS_PRERR_STS) {

		result = -1;

	}

	if (temp & GS_COL_STS) {

		result = -1;

		printk("i2c-xbox.o: SMBus collision!\n");

	}

	if (temp & GS_TO_STS) {

		result = -1;

	}

	outw_p(GS_CLEAR_STS, SMB_GLOBAL_STATUS);

	return result;

}

/* Return -1 on error. */

s32 xbox_access(struct i2c_adapter * adap, u16 addr,

		  unsigned short flags, char read_write,

		  u8 command, int size, union i2c_smbus_data * data)

{

  /** TODO: Should I supporte the 10-bit transfers? */

	switch (size) {

	case I2C_SMBUS_PROC_CALL:

		printk

		    ("i2c-xbox.o: I2C_SMBUS_PROC_CALL not supported!\n");

		/* TODO: Well... It is supported, I'm just not sure what to do here... */

		return -1;

	case I2C_SMBUS_QUICK:

		outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),

		       SMB_HOST_ADDRESS);

		size = XBOX_QUICK;

		break;

	case I2C_SMBUS_BYTE:

		outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),

		       SMB_HOST_ADDRESS);

		/* TODO: Why only during write? */

		if (read_write == I2C_SMBUS_WRITE)

			outb_p(command, SMB_HOST_COMMAND);

		size = XBOX_BYTE;

		break;

	case I2C_SMBUS_BYTE_DATA:

		outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),

		       SMB_HOST_ADDRESS);

		outb_p(command, SMB_HOST_COMMAND);

		if (read_write == I2C_SMBUS_WRITE)

			outw_p(data->byte, SMB_HOST_DATA);

		size = XBOX_BYTE_DATA;

		break;

	case I2C_SMBUS_WORD_DATA:

		outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),

		       SMB_HOST_ADDRESS);

		outb_p(command, SMB_HOST_COMMAND);

		if (read_write == I2C_SMBUS_WRITE)

			outw_p(data->word, SMB_HOST_DATA);	/* TODO: endian???? */

		size = XBOX_WORD_DATA;

		break;

	}

	/* How about enabling interrupts... */

	outw_p(size & GE_CYC_TYPE_MASK, SMB_GLOBAL_ENABLE);

	if (xbox_transaction())	/* Error in transaction */

		return -1;

	if ((read_write == I2C_SMBUS_WRITE) || (size == XBOX_QUICK))

		return 0;

	switch (size) {

	case XBOX_BYTE:

		data->byte = inw_p(SMB_HOST_DATA);

		break;

	case XBOX_BYTE_DATA:

		data->byte = inw_p(SMB_HOST_DATA);

		break;

	case XBOX_WORD_DATA:

		data->word = inw_p(SMB_HOST_DATA);	/* TODO: endian???? */

		break;

	}

	return 0;

}

u32 xbox_func(struct i2c_adapter *adapter)

{

	return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |

	    I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |

	    I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_PROC_CALL;

}

int __init i2c_xbox_init(void)

{

	int res;

	printk("i2c-xbox.o version 0.0.1\n");

	xbox_initialized = 0;

	if ((res = xbox_setup())) {

		printk

		    ("i2c-xbox.o: XBOX or compatible device not detected, module not inserted.\n");

		xbox_cleanup();

		return res;

	}

	xbox_initialized++;

	sprintf(xbox_adapter.name, "SMBus adapter at %04x",xbox_smba);

	if ((res = i2c_add_adapter(&xbox_adapter))) {

		printk

		    ("i2c-xbox.o: Adapter registration failed, module not inserted.\n");

		xbox_cleanup();

		return res;

	}

	xbox_initialized++;

	printk("i2c-xbox.o: SMBus bus detected and initialized\n");

	return 0;

}

int __init xbox_cleanup(void)

{

	int res;

	if (xbox_initialized >= 2) {

		if ((res = i2c_del_adapter(&xbox_adapter))) {

			printk

			    ("i2c-xbox.o: i2c_del_adapter failed, module not removed\n");

			return res;

		} else

			xbox_initialized--;

	}

	if (xbox_initialized >= 1) {

		release_region(xbox_smba, SMB_IOSIZE);

		xbox_initialized--;

	}

	free_irq(XBOX_dev->irq, XBOX_dev);

	return 0;

}

EXPORT_SYMBOL(i2c_xbox_init);

#ifdef MODULE

MODULE_AUTHOR("Edgar Hucek <hostmaster@ed-soft.at>");

MODULE_DESCRIPTION("XBOX nForce SMBus driver");

#ifdef MODULE_LICENSE

MODULE_LICENSE("GPL");

#endif

int init_module(void)

{

	return i2c_xbox_init();

}

void cleanup_module(void)

{

	xbox_cleanup();

}

#endif				/* MODULE */

#ifdef CONFIG_X86_XBOX

#include <linux/xbox.h>

/* Global flag indicating whether to simulate Xbox drive locking in

 * software.  There should only be one Xbox drive in a system!  This

 * variable is externally referenced by arch/i386/kernel/xboxejectfix.c. */

volatile int Xbox_simulate_drive_locked = 0;

#endif /* CONFIG_X86_XBOX */

#ifdef CONFIG_X86_XBOX

	/* If we're on an Xbox and this is an Xbox drive, simulate the lock

	   request in software.  (See arch/i386/kernel/xboxejectfix.c) */

	if (CDROM_CONFIG_FLAGS(drive)->xbox_drive && machine_is_xbox) {

		CDROM_STATE_FLAGS(drive)->door_locked = lockflag;

		Xbox_simulate_drive_locked = lockflag;

		return 0;

	}

#endif /* CONFIG_X86_XBOX */

#ifdef CONFIG_X86_XBOX

        /* Older Xbox DVD drives don't understand the ATAPI command, but the SMC

	   can do the eject.  Note that some Xbox drives support the eject

	   command, namely the Samsung, so for that drive we do a regular eject

	   sequence. */

	if (machine_is_xbox && CDROM_CONFIG_FLAGS(drive)->xbox_drive &&

		CDROM_CONFIG_FLAGS(drive)->xbox_eject) {

		if (ejectflag) {

			Xbox_tray_load();

		} else {

			Xbox_simulate_drive_locked = 0;

			Xbox_tray_eject();

		}

		return 0;

	}

#endif

#ifdef CONFIG_X86_XBOX

	/* THOMSON DVD drives in the Xbox report incorrect capabilities

	   and do not understand the ATAPI eject command, but the SMC

	   can do the eject. */

	else if ((strcmp(drive->id->model, "THOMSON-DVD") == 0)) {

		CDROM_CONFIG_FLAGS(drive)->audio_play = 1;

		CDROM_CONFIG_FLAGS(drive)->dvd = 1;

		CDROM_CONFIG_FLAGS(drive)->xbox_drive = 1;

		CDROM_CONFIG_FLAGS(drive)->xbox_eject = 1;

	}

	/* PHILIPS drives in Xboxen manufactured pre September 2003,

	   report correct capabilities, but do not understand the ATAPI

	   eject command, hence require the SMC to do so. */

	else if ((strcmp(drive->id->model, "PHILIPS XBOX DVD DRIVE") == 0)) {

		CDROM_CONFIG_FLAGS(drive)->xbox_drive = 1;

		CDROM_CONFIG_FLAGS(drive)->xbox_eject = 1;

	}

	/* PHILIPS drives in Xboxen manufactured post September 2003,

	   report incorrect capabilities, but understand the ATAPI

	   eject command. */

	else if ((strcmp(drive->id->model, "PHILIPS J5 3235C") == 0)) {

		CDROM_CONFIG_FLAGS(drive)->audio_play = 1;

		CDROM_CONFIG_FLAGS(drive)->dvd = 1;

		CDROM_CONFIG_FLAGS(drive)->xbox_drive = 1;

		CDROM_CONFIG_FLAGS(drive)->xbox_eject = 0;

	}

	/* SAMSUNG drives in the Xbox report correct capabilities

	   and understand the ATAPI eject command. */

	else if (strcmp(drive->id->model, "SAMSUNG DVD-ROM SDG-605B") == 0) {

		CDROM_CONFIG_FLAGS(drive)->xbox_drive = 1;

		CDROM_CONFIG_FLAGS(drive)->xbox_eject = 0;

	}

#endif

	/* Is an Xbox drive detected? */

#ifdef CONFIG_X86_XBOX

	if (CDROM_CONFIG_FLAGS(drive)->xbox_drive) {

#endif

		/* If an Xbox drive is present in a regular PC, we can't eject.

		   Act like the drive cannot eject, unless the ATAPI eject command

		   is supported by the drive.  If the drive doesn't support ATAPI

		   ejecting, act like door locking is impossible as well. */

#ifdef CONFIG_X86_XBOX

		if (!machine_is_xbox) {

#endif /* CONFIG_X86_XBOX */

			CDROM_CONFIG_FLAGS(drive)->no_doorlock = CDROM_CONFIG_FLAGS

				(drive)->xbox_eject;

			CDROM_CONFIG_FLAGS(drive)->no_eject = CDROM_CONFIG_FLAGS(drive)

				->xbox_eject;

#ifdef CONFIG_X86_XBOX

		} else {

			/* An Xbox drive in an Xbox.  We can support ejecting through

			   the SMC and support drive locking in software by ignoring

			   the eject interrupt (see arch/i386/kernel/xboxejectfix.c). */

			CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;

			CDROM_CONFIG_FLAGS(drive)->no_eject = 0;

			Xbox_simulate_drive_locked = 0;

		}

#endif

	}

#ifdef CONFIG_X86_XBOX

	__u8 xbox_drive         : 1; /* drive is an Xbox drive */

	__u8 xbox_eject         : 1; /* use Xbox SMC eject mechanism */	

#endif

	02a0  NV16 [GeForce3 MX - nForce GPU]

config USB_XPAD_MOUSE

       bool "Mouse emulation for Xbox controller"

       depends on USB_XPAD

       ---help---

         Say Y here if you want to enable mouse emulation for your Xbox

         controller.

         Make sure to say Y to "Mouse support" (CONFIG_INPUT_MOUSEDEV)

         and/or "Event interface support" (CONFIG_INPUT_EVDEV) as well.

xpad-objs     := xpad-core.o

ifeq ($(CONFIG_USB_XPAD_MOUSE),y)

	xpad-objs	+= xpad-mouse.o

endif

/*

 * Xbox input device driver for Linux - v0.1.4

 *

 * Copyright (c)  2002 - 2004  Marko Friedemann <mfr@bmx-chemnitz.de>

 *

 *	Contributors:

 *		Vojtech Pavlik <vojtech@suse.sz>,

 *		Oliver Schwartz <Oliver.Schwartz@gmx.de>,

 *		Steven Toth <steve@toth.demon.co.uk>,

 *		Franz Lehner <franz@caos.at>,

 *		Ivan Hawkes <blackhawk@ivanhawkes.com>

 *

 *

 * 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

 *

 *

 * This driver is based on:

 *  - information from     http://euc.jp/periphs/xbox-controller.en.html

 *  - the iForce driver    drivers/char/joystick/iforce.c

 *  - the skeleton-driver  drivers/usb/usb-skeleton.c

 *

 * Thanks to:

 *  - ITO Takayuki for providing essential xpad information on his website

 *  - Vojtech Pavlik     - iforce driver / input subsystem

 *  - Greg Kroah-Hartman - usb-skeleton driver

 *

 * TODO:

 *  - fine tune axes

 *  - fine tune mouse behaviour (should not do linear acceleration)

 *  - NEW: get rumble working correctly, fix all the bugs and support multiple

 *         simultaneous effects

 *  - NEW: split funtionality mouse/joustick into two source files

 *  - NEW: implement /proc interface (toggle mouse/rumble enable/disable, etc.)

 *  - NEW: implement user space daemon application that handles that interface

 *

 * History: moved to end of file

 */

#include <linux/config.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/slab.h>

#include <linux/module.h>

#include <linux/smp_lock.h>

#include <linux/usb.h>

#include <linux/version.h>

#include <linux/timer.h>

#include <asm/uaccess.h>

#include "xpad.h"

static struct xpad_device xpad_device[] = {

	/* please keep those ordered wrt. vendor/product ids

	  vendor, product, isMat, name                              */

	{ 0x044f, 0x0f07, 0, "Thrustmaster, Inc. Controller" },

	{ 0x045e, 0x0202, 0, "Microsoft Xbox Controller" },

	{ 0x045e, 0x0285, 0, "Microsoft Xbox Controller S" },

	{ 0x045e, 0x0289, 0, "Microsoft Xbox Controller S" }, /* microsoft is stupid */

	{ 0x046d, 0xca88, 0, "Logitech Compact Controller for Xbox" },

	{ 0x05fd, 0x1007, 0, "???Mad Catz Controller???" }, /* CHECKME: this seems strange */

	{ 0x05fd, 0x107a, 0, "InterAct PowerPad Pro" },

	{ 0x0738, 0x4516, 0, "Mad Catz Control Pad" },

	{ 0x0738, 0x4522, 0, "Mad Catz LumiCON" },

	{ 0x0738, 0x4526, 0, "Mad Catz Control Pad Pro" },

	{ 0x0738, 0x4536, 0, "Mad Catz MicroCON" },

	{ 0x0738, 0x4540, 1, "Mad Catz Beat Pad" },

	{ 0x0738, 0x4556, 0, "Mad Catz Lynx Wireless Controller" },

	{ 0x0738, 0x6040, 1, "Mad Catz Beat Pad Pro" },

	{ 0x0c12, 0x9902, 0, "HAMA VibraX - *FAULTY HARDWARE*" }, /* these are broken */

	{ 0x0e4c, 0x2390, 0, "Radica Games Jtech Controller"},	

	{ 0x0e6f, 0x0003, 0, "Logic3 Freebird wireless Controller" },

	{ 0x0f30, 0x0202, 0, "Joytech Advanced Controller" },

	{ 0x12ab, 0x8809, 1, "Xbox DDR dancepad" },

	{ 0xffff, 0xffff, 0, "Chinese-made Xbox Controller" }, /* WTF are device IDs for? */

	{ 0x0000, 0x0000, 0, "nothing detected - FAIL" }

};

static signed short xpad_btn[] = {

	BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z,	/* analogue buttons */

	BTN_START, BTN_BACK, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */

	BTN_0, BTN_1, BTN_2, BTN_3,			/* d-pad as buttons */

	-1						/* terminating entry */

};

static signed short xpad_mat_btn[] = {

	BTN_A, BTN_B, BTN_X, BTN_Y, 	/* A, B, X, Y */

	BTN_START, BTN_BACK, 		/* start/back */

	BTN_0, BTN_1, BTN_2, BTN_3,	/* directions, LEFT/RIGHT is mouse

					 * so we cannot use those! */

	-1				/* terminating entry */

};

static signed short xpad_abs[] = {

	ABS_X, ABS_Y,		/* left stick */

	ABS_RX, ABS_RY,		/* right stick */

	ABS_Z, ABS_RZ,		/* triggers left/right */

	ABS_HAT0X, ABS_HAT0Y,	/* digital pad */

	ABS_HAT1X, ABS_HAT1Y,	/* analogue buttons A + B */

	ABS_HAT2X, ABS_HAT2Y,	/* analogue buttons C + X */

	ABS_HAT3X, ABS_HAT3Y,	/* analogue buttons Y + Z */

	-1			/* terminating entry */

};

static struct usb_device_id xpad_table [] = {

	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* Xbox USB-IF not approved class */

	{ USB_INTERFACE_INFO( 3 ,  0 , 0) },	/* for Joytech Advanced Controller */

	{ }

};

MODULE_DEVICE_TABLE(usb, xpad_table);

/**

 *	xpad_process_packet

 *

 *	Completes a request by converting the data into events

 *	for the input subsystem.

 *

 *	The report descriptor was taken from ITO Takayukis website:

 *	 http://euc.jp/periphs/xbox-controller.en.html

 */

static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data, struct pt_regs *regs)

{

	struct input_dev *dev = &xpad->dev;

	input_regs(dev, regs);

	/* digital pad (button mode) bits (3 2 1 0) (right left down up) */

	input_report_key(dev, BTN_0, (data[2] & 0x01));

	input_report_key(dev, BTN_1, (data[2] & 0x08) >> 3);

	input_report_key(dev, BTN_2, (data[2] & 0x02) >> 1);

	input_report_key(dev, BTN_3, (data[2] & 0x04) >> 2);	

	/* start and back buttons */

	input_report_key(dev, BTN_START, (data[2] & 0x10) >> 4);

	input_report_key(dev, BTN_BACK, (data[2] & 0x20) >> 5);

	/* buttons A, B, X, Y digital mode */

	input_report_key(dev, BTN_A, data[4]);

	input_report_key(dev, BTN_B, data[5]);

	input_report_key(dev, BTN_X, data[6]);

	input_report_key(dev, BTN_Y, data[7]);

	if (xpad->isMat)

		return;

	/* left stick */

	input_report_abs(dev, ABS_X, ((__s16) (((__s16)data[13] << 8) | data[12])));

	input_report_abs(dev, ABS_Y, ((__s16) (((__s16)data[15] << 8) | data[14])));

	/* right stick */

	input_report_abs(dev, ABS_RX, ((__s16) (((__s16)data[17] << 8) | data[16])));

	input_report_abs(dev, ABS_RY, ((__s16) (((__s16)data[19] << 8) | data[18])));

   	/* triggers left/right */

	input_report_abs(dev, ABS_Z, data[10]);

	input_report_abs(dev, ABS_RZ, data[11]);

	/* digital pad (analogue mode): bits (3 2 1 0) (right left down up) */

	input_report_abs(dev, ABS_HAT0X, !!(data[2] & 0x08) - !!(data[2] & 0x04));

	input_report_abs(dev, ABS_HAT0Y, !!(data[2] & 0x01) - !!(data[2] & 0x02));

	/* stick press left/right */

	input_report_key(dev, BTN_THUMBL, (data[2] & 0x40) >> 6);

	input_report_key(dev, BTN_THUMBR, data[2] >> 7);

	/* button A, B, X, Y analogue mode */

	input_report_abs(dev, ABS_HAT1X, data[4]);

	input_report_abs(dev, ABS_HAT1Y, data[5]);

	input_report_abs(dev, ABS_HAT2Y, data[6]);

	input_report_abs(dev, ABS_HAT3X, data[7]);

	/* button C (black) digital/analogue mode */

	input_report_key(dev, BTN_C, data[8]);

	input_report_abs(dev, ABS_HAT2X, data[8]);

	/* button Z (white) digital/analogue mode */

	input_report_key(dev, BTN_Z, data[9]);

	input_report_abs(dev, ABS_HAT3Y, data[9]);

	input_sync(dev);

	/* process input data for mouse event generation */

	xpad_mouse_process_packet(xpad, cmd, data);

}

/**

 *	xpad_irq_in

 *

 *	Completion handler for interrupt in transfers (user input).

 *	Just calls xpad_process_packet which does then emit input events.

 */

static void xpad_irq_in(struct urb *urb, struct pt_regs *regs)

{

	struct usb_xpad *xpad = urb->context;

	int retval;

	switch (urb->status) {

	case 0:

		/* success */

		break;

	case -ECONNRESET:

	case -ENOENT:

	case -ESHUTDOWN:

		/* this urb is terminated, clean up */

		dbg("%s - urb shutting down with status: %d",

		    __FUNCTION__, urb->status);

		return;

	default:

		dbg("%s - nonzero urb status received: %d",

		    __FUNCTION__, urb->status);

		goto exit;

	}

	xpad_process_packet(xpad, 0, xpad->idata, regs);

exit:

	retval = usb_submit_urb(urb, GFP_ATOMIC);

	if (retval)

		err("%s - usb_submit_urb failed with result %d",

		    __FUNCTION__, retval);

}

/*	xpad_init_urb

 *

 *	initialize the input urb

 *	this is to be called when joystick or mouse device are opened

 */

int xpad_start_urb(struct usb_xpad *xpad)

{

	int status;

	// check if joystick or mouse device are opened

	if (xpad->open_count + xpad->mouse_open_count > 0)

		return 0;

	xpad->irq_in->dev = xpad->udev;

	if ((status = usb_submit_urb(xpad->irq_in, GFP_KERNEL))) {

		err("open input urb failed: %d", status);

		return -EIO;

	}

	return 0;

}

/**

 *	xpad_open

 *

 *	Called when a an application opens the device.

 */

static int xpad_open(struct input_dev *dev)

{

	struct usb_xpad *xpad = dev->private;

	int status;

	if (xpad->open_count)

		return 0;

	info("opening device");

	if ((status = xpad_start_urb(xpad)))

		return status;

	++xpad->open_count;

	xpad_rumble_open(xpad);

	return 0;

}

void xpad_stop_urb(struct usb_xpad *xpad)

{

	if (xpad->open_count + xpad->mouse_open_count > 0)

		return;

	usb_unlink_urb(xpad->irq_in);

}

/**

 *	xpad_close

 *

 *	Called when an application closes the device.

 */

static void xpad_close(struct input_dev *dev)

{

	struct usb_xpad *xpad = dev->private;

	if (--xpad->open_count)

		return;

	info("closing device");

	xpad_stop_urb(xpad);

	xpad_rumble_close(xpad);

}

/**	xpad_init_input_device

 *

 *	setup the input device for the kernel

 */

static void xpad_init_input_device(struct usb_interface *intf, struct xpad_device device)

{

	struct usb_xpad *xpad = usb_get_intfdata(intf);

	struct usb_device *udev = interface_to_usbdev(intf);

	char path[64];

	int i;

	xpad->dev.id.bustype = BUS_USB;

	xpad->dev.id.vendor = udev->descriptor.idVendor;

	xpad->dev.id.product = udev->descriptor.idProduct;

	xpad->dev.id.version = udev->descriptor.bcdDevice;

	xpad->dev.dev = &intf->dev;

	xpad->dev.private = xpad;

	xpad->dev.name = device.name;

	xpad->dev.phys = xpad->phys;

	xpad->dev.open = xpad_open;

	xpad->dev.close = xpad_close;

	usb_make_path(udev, path, 64);

	snprintf(xpad->phys, 64, "%s/input0", path);

	/* this was meant to allow a user space tool on-the-fly configuration

	   of driver options (mouse on, rumble on, etc)

	   yet, Vojtech said this is better done using sysfs (linux 2.6)

	   plus, it needs a patch to the input subsystem */

//	xpad->dev.ioctl = xpad_ioctl;

	if (xpad->isMat) {

		xpad->dev.evbit[0] = BIT(EV_KEY);

		for (i = 0; xpad_mat_btn[i] >= 0; ++i)

			set_bit(xpad_mat_btn[i], xpad->dev.keybit);

	} else {

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

		for (i = 0; xpad_btn[i] >= 0; ++i)

		set_bit(xpad_btn[i], xpad->dev.keybit);

		for (i = 0; xpad_abs[i] >= 0; ++i) {

			signed short t = xpad_abs[i];

			set_bit(t, xpad->dev.absbit);

			switch (t) {

			case ABS_X:

			case ABS_Y:

			case ABS_RX:

			case ABS_RY:	/* the two sticks */

				xpad->dev.absmax[t] =  32767;

				xpad->dev.absmin[t] = -32768;

				xpad->dev.absflat[t] = 128;

				xpad->dev.absfuzz[t] = 16;

				break;

			case ABS_Z:	/* left trigger */

			case ABS_RZ:	/* right trigger */

			case ABS_HAT1X:	/* analogue button A */

			case ABS_HAT1Y:	/* analogue button B */

			case ABS_HAT2X:	/* analogue button C */

			case ABS_HAT2Y:	/* analogue button X */

			case ABS_HAT3X:	/* analogue button Y */

			case ABS_HAT3Y:	/* analogue button Z */

				xpad->dev.absmax[t] = 255;

				xpad->dev.absmin[t] = 0;

				break;

			case ABS_HAT0X:

			case ABS_HAT0Y:	/* the d-pad */

				xpad->dev.absmax[t] =  1;

				xpad->dev.absmin[t] = -1;

				break;

			}

		}

		if (xpad_rumble_probe(udev, xpad, ifnum) != 0)

			err("could not init rumble");

	}

	input_register_device(&xpad->dev);

	printk(KERN_INFO "input: %s on %s\n", xpad->dev.name, path);

}

/**

 *	xpad_probe

 *

 *	Called upon device detection to find a suitable driver.

 *	Must return NULL when no xpad is found, else setup everything.

 */

static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id)

{

	struct usb_device *udev = interface_to_usbdev(intf);

	struct usb_xpad *xpad = NULL;

	struct usb_endpoint_descriptor *ep_irq_in;

	int i;

	int probedDevNum = -1;	/* this takes the index into the known devices

				   array for the recognized device */

	// try to detect the device we are called for

	for (i = 0; xpad_device[i].idVendor; ++i) {

		if ((udev->descriptor.idVendor == xpad_device[i].idVendor) &&

		    (udev->descriptor.idProduct == xpad_device[i].idProduct)) {

			probedDevNum = i;

			break;

		}

	}

	// sanity check, did we recognize this device? if not, fail

	if ((probedDevNum == -1) || (!xpad_device[probedDevNum].idVendor &&

				     !xpad_device[probedDevNum].idProduct))

		return -ENODEV;

	if ((xpad = kmalloc (sizeof(struct usb_xpad), GFP_KERNEL)) == NULL) {

		err("cannot allocate memory for new pad");

		return -ENOMEM;

	}

	memset(xpad, 0, sizeof(struct usb_xpad));

	xpad->idata = usb_buffer_alloc(udev, XPAD_PKT_LEN,

				       SLAB_ATOMIC, &xpad->idata_dma);

	if (!xpad->idata) {

		kfree(xpad);

		return -ENOMEM;

	}

	/* setup input interrupt pipe (button and axis state) */

	xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);

        if (!xpad->irq_in) {

		err("cannot allocate memory for new pad irq urb");

		usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);

                kfree(xpad);

                return -ENOMEM;

	}

	ep_irq_in = &intf->altsetting[0].endpoint[0].desc;

	xpad->udev = udev;

	xpad->isMat = xpad_device[probedDevNum].isMat;

	/* init input URB for USB INT transfer from device */

	usb_fill_int_urb(xpad->irq_in, udev,

			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),

			 xpad->idata, XPAD_PKT_LEN,

			 xpad_irq_in, xpad, ep_irq_in->bInterval);

	xpad->irq_in->transfer_dma = xpad->idata_dma;

	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	// we set this here so we can extract it in the two functions below

	usb_set_intfdata(intf, xpad);

	xpad_init_input_device(intf, xpad_device[probedDevNum]);

	xpad_mouse_init_input_device(intf, xpad_device[probedDevNum]);

	return 0;

}

/**

 *	xpad_disconnect

 *

 *	Called upon device disconnect to dispose of the structures and

 *	close the USB connections.

 */

static void xpad_disconnect(struct usb_interface *intf)

{

	struct usb_xpad *xpad = usb_get_intfdata(intf);

	usb_set_intfdata(intf, NULL);

	if (xpad) {

		info( "disconnecting device" );

		usb_unlink_urb(xpad->irq_in);

		xpad_rumble_close(xpad);

		input_unregister_device(&xpad->dev);

		usb_free_urb(xpad->irq_in);

		xpad_mouse_cleanup(xpad);

		usb_buffer_free(interface_to_usbdev(intf), XPAD_PKT_LEN,

				xpad->idata, xpad->idata_dma);

		xpad_rumble_disconnect(xpad);

		kfree(xpad);

	}

}

/******************* Linux driver framework specific stuff ************/

static struct usb_driver xpad_driver = {

	.owner		= THIS_MODULE,

	.name		= "xpad",

	.probe		= xpad_probe,

	.disconnect	= xpad_disconnect,

	.id_table	= xpad_table,

};

/**

 * driver init entry point

 */

static int __init usb_xpad_init(void)

{

	int result = usb_register(&xpad_driver);

	if (result == 0)

		info(DRIVER_DESC " " DRIVER_VERSION);

	return result;

}

/**

 * driver exit entry point

 */

static void __exit usb_xpad_exit(void)

{

	usb_deregister(&xpad_driver);

}

module_init(usb_xpad_init);

module_exit(usb_xpad_exit);

MODULE_AUTHOR(DRIVER_AUTHOR);

MODULE_DESCRIPTION(DRIVER_DESC);

MODULE_LICENSE("GPL");

/*

 *  driver history

 * ----------------

 *

 * 2003-05-15 - 0.1.2 : ioctls, dynamic mouse/rumble activation, /proc fs

 *  - added some /proc files for informational purposes (readonly right now)

 *  - added init parameters for mouse/rumble activation upon detection

 *  - added dynamic changes to mouse events / rumble effect generation via

 *    ioctls - NOTE: this requires a currently unofficial joydev patch!

 *

 * 2003-04-29 - 0.1.1 : minor cleanups, some comments

 *  - fixed incorrect handling of unknown devices (please try ir dongle now)

 *  - fixed input URB length (the 256 bytes from 0.1.0 broke everything for the

 *    MS controller as well as my Interact device, set back to 32 (please

 *    REPORT problems BEFORE any further changes here, since those can be fatal)

 *  - fixed rumbling for MS controllers (need 6 bytes output report)

 *  - dropped kernel-2.5 ifdefs, much more readable now

 *  - preparation for major rework under way, stay tuned

 *

 * 2003-03-25 - 0.1.0 : (Franz) Some Debuggin

 *  - Better Handling

 *  - X/Y support, Speed differenting

 *  - Landing Zone, Dead Zone, Offset kompensation, Zero-adjustment, .... aso.

 *  - Removed Wheel handling in Mouse Emulation .. sensless..

 *

 * 2003-01-23 - 0.1.0-pre : added mouse emulation and rumble support

 *  - can provide mouse emulation (compile time switch)

 *    this code has been taken from Oliver Schwartz' xpad-mouse driver

 *  - basic rumble support (compile time switch)        EXPERIMENTAL!  

 *

 * 2002-08-05 - 0.0.6 : added analog button support

 *

 * 2002-07-17 - 0.0.5 : (Vojtech Pavlik) rework

 *  - simplified d-pad handling

 *

 * 2002-07-16 - 0.0.4 : minor changes, merge with Vojtech's v0.0.3

 *  - verified the lack of HID and report descriptors

 *  - verified that ALL buttons WORK

 *  - fixed d-pad to axes mapping

 *

 * 2002-07-14 - 0.0.3 : (Vojtech Pavlik) rework

 *  - indentation fixes

 *  - usb + input init sequence fixes

 *

 * 2002-07-02 - 0.0.2 : basic working version

 *  - all axes and 9 of the 10 buttons work (german InterAct device)

 *  - the black button does not work

 *

 * 2002-06-27 - 0.0.1 : first version, just said "XBOX HID controller"

 */

/*

 * Xbox input device driver for Linux - v0.1.4

 *

 *	mouse emulation stuff, merged from Olivers xpad-mouse

 *

 * Copyright (c)  2003, 2004  Marko Friedemann <mfr@bmx-chemnitz.de>

 *	portions Copyright (c)	2002  Oliver Schwartz <Oliver.Schwartz@gmx.de>,

 *				2003  Franz Lehner <franz@chaos.at>

 *

 * Released under GPL. See xpad-core.c for details

 */

#include <linux/config.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/slab.h>

#include <linux/module.h>

#include <linux/smp_lock.h>

#include <linux/proc_fs.h>

#include <linux/usb.h>

#include <linux/version.h>

#include <linux/timer.h>

#include <asm/uaccess.h>

#define __USB_XPAD_MOUSE

#include "xpad.h"

#undef __USB_XPAD_MOUSE

#define XPAD_WHEELBRAKE		20

#define JOY_DeadZone_fast	6000

#define JOY_DeadZone_slow	200

#define XPAD_OFFSET_COUNTER	5

static int mouse_on_load = 1;

MODULE_PARM( mouse_on_load, "i" );

MODULE_PARM_DESC( mouse_on_load, "set to 0 to deactivate mouse support on insmod (default 1)" );

/**

 *	xpad_removedeadzone

 *

 *	Franz? Please clarify and correct.

 *

 *	Removes the deadzone for mouse operation.

 *	Allows for better handling near the stick's center.

 */   

static int xpad_mouse_removedeadzone(signed int position, int speed, int deadzone)

{

	if (position>31000) position=31000;

	if (position<-31000) position=-31000; 

	if ((position>0)&(position<deadzone)) return 0;

	if ((position<0)&(position>(-deadzone))) return 0;

	if (position>deadzone) position -= deadzone;	

	if (position<(-(deadzone))) position+= deadzone;	

	position = (int)(position / speed);

	return position;

}

void xpad_mouse_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)

{

        struct input_dev *dev_mouse = &xpad->dev_mouse;

        int signledirection, xyspeed;

        //int joy_y2;

	unsigned char MouseLeft,MouseRight, MouseMiddle;

        signed int left_joy_x, left_joy_y, right_joy_x, right_joy_y;

	if (!xpad->mouse_open_count || !xpad->mouse_enabled)

		return;

	left_joy_x = ((__s16) (((__s16)data[13] << 8) | data[12]));

	left_joy_y = ((__s16) (((__s16)data[15] << 8) | data[14]));

	right_joy_x = ((__s16) (((__s16)data[17] << 8) | data[16]));

	right_joy_y = ((__s16) (((__s16)data[19] << 8) | data[18]));

	// Creates Offset when first starting

	/* CHECKME: who coded this? Franz? Please clarify:

		1) is this necessary for joystick operation?

		2) offset_counter was only defined when MOUSE

		   support was configured (has been FIXED, see above) */

	if (xpad->offsetset_compensation>0) {

		if (xpad->offsetset_compensation == XPAD_OFFSET_COUNTER) {

			xpad->left_offset_x  = left_joy_x;

			xpad->left_offset_y  = left_joy_y;

			xpad->right_offset_x = right_joy_x;

			xpad->right_offset_y = right_joy_y;  

		} else {

			xpad->left_offset_x  += left_joy_x;

			xpad->left_offset_y  += left_joy_y;

			xpad->right_offset_x += right_joy_x;

			xpad->right_offset_y += right_joy_y;  

		}

		if (xpad->offsetset_compensation == 1) {

			xpad->left_offset_x  = xpad->left_offset_x  / XPAD_OFFSET_COUNTER;

			xpad->left_offset_y  = xpad->left_offset_y  / XPAD_OFFSET_COUNTER;

			xpad->right_offset_x = xpad->right_offset_x / XPAD_OFFSET_COUNTER;

			xpad->right_offset_y = xpad->right_offset_y / XPAD_OFFSET_COUNTER;  

		}

		xpad->offsetset_compensation--;

	}

	left_joy_x -= xpad->left_offset_x;

	left_joy_y -= xpad->left_offset_y;

	right_joy_x -= xpad->right_offset_x;

	right_joy_y -= xpad->right_offset_y;

	if (data[11]<0x10) {

		// Normal Speed Mode

		xpad->rel_x =  (xpad_mouse_removedeadzone(left_joy_x,0x1500,JOY_DeadZone_fast));

		xpad->rel_y = -(xpad_mouse_removedeadzone(left_joy_y,0x1500,JOY_DeadZone_fast));

		xyspeed = 2;

		//printk("%d:",xpad->rel_y);

	} else {

		// Ultra Slow Mode                                                 

		xpad->rel_x =  (xpad_mouse_removedeadzone(left_joy_x,0x3500,JOY_DeadZone_slow));

		xpad->rel_y = -(xpad_mouse_removedeadzone(left_joy_y,0x3500,JOY_DeadZone_slow));    

		xyspeed = 1;

	}

	// X-Y Steering

	signledirection=1;

	if (signledirection&((data[2] & 0x04)!=0)) { signledirection=0; xpad->rel_x -=xyspeed; }

	if (signledirection&((data[2] & 0x08)!=0)) { signledirection=0; xpad->rel_x +=xyspeed; }

	if (signledirection&((data[2] & 0x02)!=0)) { signledirection=0; xpad->rel_y +=xyspeed; }

	if (signledirection&((data[2] & 0x01)!=0)) { signledirection=0; xpad->rel_y -=xyspeed; }

	/* wheel handling */

	//joy_y2 = xpad_mouse_removedeadzone(joy_y2);

	//xpad->rel_wheel = (joy_y2>0)?1:(joy_y2<0)?-1:0;

	xpad->rel_wheel=0;

	if (data[10]==0xFF) MouseLeft=1; else MouseLeft =0;

	if ((MouseLeft==0)&(data[7]!=0)) MouseLeft =1;

	if ((MouseLeft==0)&(data[4]!=0)) MouseLeft = 1;

	if ((MouseLeft==0)&((data[2] >> 7)!=0)) MouseLeft = 1;

	if ((MouseLeft==0)&(((data[2] & 0x40) >> 6)!=0)) MouseLeft = 1;

	if (data[5]!=0) MouseRight=1; else MouseRight=0;

	if (data[6]!=0) MouseMiddle =1; else MouseMiddle=0;

	// Generating Mouse Emulation Events  (Button Events)

	input_report_key(dev_mouse, BTN_LEFT, MouseLeft);

	input_report_key(dev_mouse, BTN_RIGHT, MouseRight);

	input_report_key(dev_mouse, BTN_MIDDLE, MouseMiddle);

	input_sync(dev_mouse);

}

/**

 *	xpad_timer

 *

 *	Reports the mouse events in the interval given in xpad_open.

 *

 *	Taken from Oliver Schwartz' xpad-mouse driver to avoid strange mouse

 *	 behaviour encountered when the input events where send directly

 *	 in xpad_process_packet.

 */

static void xpad_timer(unsigned long data)

{

	struct usb_xpad *xpad = (struct usb_xpad *)data;

	if (xpad->mouse_enabled) {

		input_report_rel(&xpad->dev_mouse, REL_X, xpad->rel_x);

		input_report_rel(&xpad->dev_mouse, REL_Y, xpad->rel_y); 

		input_sync(&xpad->dev_mouse);

		/*if (xpad->rel_wheeltimer == 0) {

			input_report_rel(&xpad->dev_mouse, REL_WHEEL, xpad->rel_wheel);

			xpad->rel_wheeltimer = XPAD_WHEELBRAKE;

		} else

			xpad->rel_wheeltimer--;*/

	}

	// reschedule the timer so that it fires continually

	add_timer(&xpad->timer);

}

static int xpad_mouse_open(struct input_dev *dev)

{

	struct usb_xpad *xpad = dev->private;

	int status;

	if (xpad->mouse_open_count)

		return 0;

	if ((status = xpad_start_urb(xpad)))

		return status;

	++xpad->mouse_open_count;

	info("opening mouse device");

	// set up timer for mouse event generation

	init_timer(&xpad->timer);

	xpad->timer.expires = 1*HZ/5; /* every 200 ms */

	xpad->timer.data = (unsigned long)xpad;

	xpad->timer.function = xpad_timer;

	// now start the timer

	add_timer(&xpad->timer);

	return 0;

}

static void xpad_mouse_close(struct input_dev *dev)

{

	struct usb_xpad *xpad = dev->private;

	if (--xpad->mouse_open_count)

		return;

	xpad_stop_urb(xpad);

	info("closing mouse device"); 

	del_timer(&xpad->timer);

}

int xpad_mouse_init_input_device(struct usb_interface *intf, struct xpad_device device)

{

	struct usb_xpad *xpad = usb_get_intfdata(intf);

	struct usb_device *udev = interface_to_usbdev(intf);

	/* the mouse device struct for the kernel (mouse emulation) */

	xpad->dev_mouse.id.bustype = BUS_USB;

	xpad->dev_mouse.id.vendor = udev->descriptor.idVendor;

	xpad->dev_mouse.id.product = udev->descriptor.idProduct;

	xpad->dev_mouse.id.version = udev->descriptor.bcdDevice;

	xpad->dev_mouse.dev = &intf->dev;

	xpad->dev_mouse.private = xpad;

	xpad->dev_mouse.name = device.name;

	xpad->dev_mouse.phys = xpad->phys;

	xpad->dev_mouse.open = xpad_mouse_open;

	xpad->dev_mouse.close = xpad_mouse_close;

	xpad->offsetset_compensation = XPAD_OFFSET_COUNTER; // Find new offset point

	xpad->mouse_enabled = mouse_on_load;

	/* mouse setup */

	xpad->dev_mouse.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);

	set_bit(REL_X,     xpad->dev_mouse.relbit);

	set_bit(REL_Y,     xpad->dev_mouse.relbit);

	set_bit(REL_WHEEL, xpad->dev_mouse.relbit);

	set_bit(BTN_LEFT,   xpad->dev_mouse.keybit);

	set_bit(BTN_RIGHT,  xpad->dev_mouse.keybit);

	set_bit(BTN_MIDDLE, xpad->dev_mouse.keybit);

	set_bit(BTN_SIDE,   xpad->dev_mouse.keybit);

	set_bit(BTN_EXTRA,  xpad->dev_mouse.keybit);

	input_register_device(&xpad->dev_mouse);

	printk(KERN_INFO "input: mouse emulation %s@ %s\n",

	       (mouse_on_load ? "" : "(disabled) "), xpad->dev_mouse.name);

}

void xpad_mouse_cleanup(struct usb_xpad *xpad)

{

	// the timer exists only when the mouse device is used

	if (xpad->mouse_open_count)

		del_timer(&xpad->timer);

	input_unregister_device(&xpad->dev_mouse);

}

/*

 * Xbox Controller driver for Linux - v0.1.4

 *

 *	header file containing ioctl definitions

 *