Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 86ae13b006e48959981248493efd3ff4b2828b3d

Authored by Ingo Molnar 2009-10-12 22:22:46 +0800

Committed by Linus Torvalds 2009-10-14 01:20:16 +0800

Exists in master and in 7 other branches

headers: Fix build after <linux/sched.h> removal

Commit d43c36dc6b357fa1806800f18aa30123c747a6d1 ("headers: remove
sched.h from interrupt.h") left some build errors in some configurations
due to drivers having depended on getting header files "accidentally".

Signed-off-by: Ingo Molnar <mingo@elte.hu>
[ Combined several one-liners from Ingo into one single patch  - Linus ]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 7 changed files with 7 additions and 0 deletions Inline Diff

drivers/char/genrtc.c
drivers/char/rtc.c
drivers/char/sonypi.c
drivers/net/wan/c101.c
drivers/net/wan/n2.c
drivers/net/wan/pci200syn.c
drivers/pci/hotplug/cpqphp.h

drivers/char/genrtc.c

Diff comments View file @ 86ae13b

 /*
  *	Real Time Clock interface for
  *		- q40 and other m68k machines,
  *		- HP PARISC machines
  *		- PowerPC machines
  *      emulate some RTC irq capabilities in software
  *
  *      Copyright (C) 1999 Richard Zidlicky
  *
  *	based on Paul Gortmaker's rtc.c device and
  *           Sam Creasey Generic rtc driver
  *
  *	This driver allows use of the real time clock (built into
  *	nearly all computers) from user space. It exports the /dev/rtc
  *	interface supporting various ioctl() and also the /proc/driver/rtc
  *	pseudo-file for status information.
  *
  *	The ioctls can be used to set the interrupt behaviour where
  *	supported.
  *
  *	The /dev/rtc interface will block on reads until an interrupt
  *	has been received. If a RTC interrupt has already happened,
  *	it will output an unsigned long and then block. The output value
  *	contains the interrupt status in the low byte and the number of
  *	interrupts since the last read in the remaining high bytes. The
  *	/dev/rtc interface can also be used with the select(2) call.
  *
  *	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.
  *
  *      1.01 fix for 2.3.X                    rz@linux-m68k.org
  *      1.02 merged with code from genrtc.c   rz@linux-m68k.org
  *      1.03 make it more portable            zippel@linux-m68k.org
  *      1.04 removed useless timer code       rz@linux-m68k.org
  *      1.05 portable RTC_UIE emulation       rz@linux-m68k.org
  *      1.06 set_rtc_time can return an error trini@kernel.crashing.org
  *      1.07 ported to HP PARISC (hppa)	      Helge Deller <deller@gmx.de>
  */
 #define RTC_VERSION	"1.07"
 #include <linux/module.h>
+#include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/miscdevice.h>
 #include <linux/fcntl.h>
 #include <linux/rtc.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
 #include <linux/smp_lock.h>
 #include <linux/workqueue.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/rtc.h>
 /*
  *	We sponge a minor off of the misc major. No need slurping
  *	up another valuable major dev number for this. If you add
  *	an ioctl, make sure you don't conflict with SPARC's RTC
  *	ioctls.
  */
 static DECLARE_WAIT_QUEUE_HEAD(gen_rtc_wait);
 /*
  *	Bits in gen_rtc_status.
  */
 #define RTC_IS_OPEN		0x01	/* means /dev/rtc is in use	*/
 static unsigned char gen_rtc_status;	/* bitmapped status byte.	*/
 static unsigned long gen_rtc_irq_data;	/* our output to the world	*/
 /* months start at 0 now */
 static unsigned char days_in_mo[] =
 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 static int irq_active;
 #ifdef CONFIG_GEN_RTC_X
 static struct work_struct genrtc_task;
 static struct timer_list timer_task;
 static unsigned int oldsecs;
 static int lostint;
 static unsigned long tt_exp;
 static void gen_rtc_timer(unsigned long data);
 static volatile int stask_active;              /* schedule_work */
 static volatile int ttask_active;              /* timer_task */
 static int stop_rtc_timers;                    /* don't requeue tasks */
 static DEFINE_SPINLOCK(gen_rtc_lock);
 static void gen_rtc_interrupt(unsigned long arg);
 /*
  * Routine to poll RTC seconds field for change as often as possible,
  * after first RTC_UIE use timer to reduce polling
  */
 static void genrtc_troutine(struct work_struct *work)
 {
 	unsigned int tmp = get_rtc_ss();
 	if (stop_rtc_timers) {
 		stask_active = 0;
 		return;
 	}
 	if (oldsecs != tmp){
 		oldsecs = tmp;
 		timer_task.function = gen_rtc_timer;
 		timer_task.expires = jiffies + HZ - (HZ/10);
 		tt_exp=timer_task.expires;
 		ttask_active=1;
 		stask_active=0;
 		add_timer(&timer_task);
 		gen_rtc_interrupt(0);
 	} else if (schedule_work(&genrtc_task) == 0)
 		stask_active = 0;
 }
 static void gen_rtc_timer(unsigned long data)
 {
 	lostint = get_rtc_ss() - oldsecs ;
 	if (lostint<0)
 		lostint = 60 - lostint;
 	if (time_after(jiffies, tt_exp))
 		printk(KERN_INFO "genrtc: timer task delayed by %ld jiffies\n",
 		       jiffies-tt_exp);
 	ttask_active=0;
 	stask_active=1;
 	if ((schedule_work(&genrtc_task) == 0))
 		stask_active = 0;
 }
 /*
  * call gen_rtc_interrupt function to signal an RTC_UIE,
  * arg is unused.
  * Could be invoked either from a real interrupt handler or
  * from some routine that periodically (eg 100HZ) monitors
  * whether RTC_SECS changed
  */
 static void gen_rtc_interrupt(unsigned long arg)
 {
 	/*  We store the status in the low byte and the number of
 	 *	interrupts received since the last read in the remainder
 	 *	of rtc_irq_data.  */
 	gen_rtc_irq_data += 0x100;
 	gen_rtc_irq_data &= ~0xff;
 	gen_rtc_irq_data |= RTC_UIE;
 	if (lostint){
 		printk("genrtc: system delaying clock ticks?\n");
 		/* increment count so that userspace knows something is wrong */
 		gen_rtc_irq_data += ((lostint-1)<<8);
 		lostint = 0;
 	}
 	wake_up_interruptible(&gen_rtc_wait);
 }
 /*
  *	Now all the various file operations that we export.
  */
 static ssize_t gen_rtc_read(struct file *file, char __user *buf,
 			size_t count, loff_t *ppos)
 {
 	unsigned long data;
 	ssize_t retval;
 	if (count != sizeof (unsigned int) && count != sizeof (unsigned long))
 		return -EINVAL;
 	if (file->f_flags & O_NONBLOCK && !gen_rtc_irq_data)
 		return -EAGAIN;
 	retval = wait_event_interruptible(gen_rtc_wait,
 			(data = xchg(&gen_rtc_irq_data, 0)));
 	if (retval)
 		goto out;
 	/* first test allows optimizer to nuke this case for 32-bit machines */
 	if (sizeof (int) != sizeof (long) && count == sizeof (unsigned int)) {
 		unsigned int uidata = data;
 		retval = put_user(uidata, (unsigned int __user *)buf) ?:
 			sizeof(unsigned int);
 	}
 	else {
 		retval = put_user(data, (unsigned long __user *)buf) ?:
 			sizeof(unsigned long);
 	}
 out:
 	return retval;
 }
 static unsigned int gen_rtc_poll(struct file *file,
 				 struct poll_table_struct *wait)
 {
 	poll_wait(file, &gen_rtc_wait, wait);
 	if (gen_rtc_irq_data != 0)
 		return POLLIN | POLLRDNORM;
 	return 0;
 }
 #endif
 /*
  * Used to disable/enable interrupts, only RTC_UIE supported
  * We also clear out any old irq data after an ioctl() that
  * meddles with the interrupt enable/disable bits.
  */
 static inline void gen_clear_rtc_irq_bit(unsigned char bit)
 {
 #ifdef CONFIG_GEN_RTC_X
 	stop_rtc_timers = 1;
 	if (ttask_active){
 		del_timer_sync(&timer_task);
 		ttask_active = 0;
 	}
 	while (stask_active)
 		schedule();
 	spin_lock(&gen_rtc_lock);
 	irq_active = 0;
 	spin_unlock(&gen_rtc_lock);
 #endif
 }
 static inline int gen_set_rtc_irq_bit(unsigned char bit)
 {
 #ifdef CONFIG_GEN_RTC_X
 	spin_lock(&gen_rtc_lock);
 	if ( !irq_active ) {
 		irq_active = 1;
 		stop_rtc_timers = 0;
 		lostint = 0;
 		INIT_WORK(&genrtc_task, genrtc_troutine);
 		oldsecs = get_rtc_ss();
 		init_timer(&timer_task);
 		stask_active = 1;
 		if (schedule_work(&genrtc_task) == 0){
 			stask_active = 0;
 		}
 	}
 	spin_unlock(&gen_rtc_lock);
 	gen_rtc_irq_data = 0;
 	return 0;
 #else
 	return -EINVAL;
 #endif
 }
 static int gen_rtc_ioctl(struct inode *inode, struct file *file,
 			 unsigned int cmd, unsigned long arg)
 {
 	struct rtc_time wtime;
 	struct rtc_pll_info pll;
 	void __user *argp = (void __user *)arg;
 	switch (cmd) {
 	case RTC_PLL_GET:
 	    if (get_rtc_pll(&pll))
 	 	    return -EINVAL;
 	    else
 		    return copy_to_user(argp, &pll, sizeof pll) ? -EFAULT : 0;
 	case RTC_PLL_SET:
 		if (!capable(CAP_SYS_TIME))
 			return -EACCES;
 		if (copy_from_user(&pll, argp, sizeof(pll)))
 			return -EFAULT;
 	    return set_rtc_pll(&pll);
 	case RTC_UIE_OFF:	/* disable ints from RTC updates.	*/
 		gen_clear_rtc_irq_bit(RTC_UIE);
 		return 0;
 	case RTC_UIE_ON:	/* enable ints for RTC updates.	*/
 	        return gen_set_rtc_irq_bit(RTC_UIE);
 	case RTC_RD_TIME:	/* Read the time/date from RTC	*/
 		/* this doesn't get week-day, who cares */
 		memset(&wtime, 0, sizeof(wtime));
 		get_rtc_time(&wtime);
 		return copy_to_user(argp, &wtime, sizeof(wtime)) ? -EFAULT : 0;
 	case RTC_SET_TIME:	/* Set the RTC */
 	    {
 		int year;
 		unsigned char leap_yr;
 		if (!capable(CAP_SYS_TIME))
 			return -EACCES;
 		if (copy_from_user(&wtime, argp, sizeof(wtime)))
 			return -EFAULT;
 		year = wtime.tm_year + 1900;
 		leap_yr = ((!(year % 4) && (year % 100)) ||
 			   !(year % 400));
 		if ((wtime.tm_mon < 0 || wtime.tm_mon > 11) || (wtime.tm_mday < 1))
 			return -EINVAL;
 		if (wtime.tm_mday < 0 || wtime.tm_mday >
 		    (days_in_mo[wtime.tm_mon] + ((wtime.tm_mon == 1) && leap_yr)))
 			return -EINVAL;
 		if (wtime.tm_hour < 0 || wtime.tm_hour >= 24 ||
 		    wtime.tm_min < 0 || wtime.tm_min >= 60 ||
 		    wtime.tm_sec < 0 || wtime.tm_sec >= 60)
 			return -EINVAL;
 		return set_rtc_time(&wtime);
 	    }
 	}
 	return -EINVAL;
 }
 /*
  *	We enforce only one user at a time here with the open/close.
  *	Also clear the previous interrupt data on an open, and clean
  *	up things on a close.
  */
 static int gen_rtc_open(struct inode *inode, struct file *file)
 {
 	lock_kernel();
 	if (gen_rtc_status & RTC_IS_OPEN) {
 		unlock_kernel();
 		return -EBUSY;
 	}
 	gen_rtc_status |= RTC_IS_OPEN;
 	gen_rtc_irq_data = 0;
 	irq_active = 0;
 	unlock_kernel();
 	return 0;
 }
 static int gen_rtc_release(struct inode *inode, struct file *file)
 {
 	/*
 	 * Turn off all interrupts once the device is no longer
 	 * in use and clear the data.
 	 */
 	gen_clear_rtc_irq_bit(RTC_PIE|RTC_AIE|RTC_UIE);
 	gen_rtc_status &= ~RTC_IS_OPEN;
 	return 0;
 }
 #ifdef CONFIG_PROC_FS
 /*
  *	Info exported via "/proc/driver/rtc".
  */
 static int gen_rtc_proc_output(char *buf)
 {
 	char *p;
 	struct rtc_time tm;
 	unsigned int flags;
 	struct rtc_pll_info pll;
 	p = buf;
 	flags = get_rtc_time(&tm);
 	p += sprintf(p,
 		     "rtc_time\t: %02d:%02d:%02d\n"
 		     "rtc_date\t: %04d-%02d-%02d\n"
 		     "rtc_epoch\t: %04u\n",
 		     tm.tm_hour, tm.tm_min, tm.tm_sec,
 		     tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, 1900);
 	tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
 	p += sprintf(p, "alarm\t\t: ");
 	if (tm.tm_hour <= 24)
 		p += sprintf(p, "%02d:", tm.tm_hour);
 	else
 		p += sprintf(p, "**:");
 	if (tm.tm_min <= 59)
 		p += sprintf(p, "%02d:", tm.tm_min);
 	else
 		p += sprintf(p, "**:");
 	if (tm.tm_sec <= 59)
 		p += sprintf(p, "%02d\n", tm.tm_sec);
 	else
 		p += sprintf(p, "**\n");
 	p += sprintf(p,
 		     "DST_enable\t: %s\n"
 		     "BCD\t\t: %s\n"
 		     "24hr\t\t: %s\n"
 		     "square_wave\t: %s\n"
 		     "alarm_IRQ\t: %s\n"
 		     "update_IRQ\t: %s\n"
 		     "periodic_IRQ\t: %s\n"
 		     "periodic_freq\t: %ld\n"
 		     "batt_status\t: %s\n",
 		     (flags & RTC_DST_EN) ? "yes" : "no",
 		     (flags & RTC_DM_BINARY) ? "no" : "yes",
 		     (flags & RTC_24H) ? "yes" : "no",
 		     (flags & RTC_SQWE) ? "yes" : "no",
 		     (flags & RTC_AIE) ? "yes" : "no",
 		     irq_active ? "yes" : "no",
 		     (flags & RTC_PIE) ? "yes" : "no",
 		     0L /* freq */,
 		     (flags & RTC_BATT_BAD) ? "bad" : "okay");
 	if (!get_rtc_pll(&pll))
 	    p += sprintf(p,
 			 "PLL adjustment\t: %d\n"
 			 "PLL max +ve adjustment\t: %d\n"
 			 "PLL max -ve adjustment\t: %d\n"
 			 "PLL +ve adjustment factor\t: %d\n"
 			 "PLL -ve adjustment factor\t: %d\n"
 			 "PLL frequency\t: %ld\n",
 			 pll.pll_value,
 			 pll.pll_max,
 			 pll.pll_min,
 			 pll.pll_posmult,
 			 pll.pll_negmult,
 			 pll.pll_clock);
 	return p - buf;
 }
 static int gen_rtc_read_proc(char *page, char **start, off_t off,
 			     int count, int *eof, void *data)
 {
 	int len = gen_rtc_proc_output (page);
         if (len <= off+count) *eof = 1;
 	*start = page + off;
 	len -= off;
         if (len>count) len = count;
         if (len<0) len = 0;
 	return len;
 }
 static int __init gen_rtc_proc_init(void)
 {
 	struct proc_dir_entry *r;
 	r = create_proc_read_entry("driver/rtc", 0, NULL, gen_rtc_read_proc, NULL);
 	if (!r)
 		return -ENOMEM;
 	return 0;
 }
 #else
 static inline int gen_rtc_proc_init(void) { return 0; }
 #endif /* CONFIG_PROC_FS */
 /*
  *	The various file operations we support.
  */
 static const struct file_operations gen_rtc_fops = {
 	.owner		= THIS_MODULE,
 #ifdef CONFIG_GEN_RTC_X
 	.read		= gen_rtc_read,
 	.poll		= gen_rtc_poll,
 #endif
 	.ioctl		= gen_rtc_ioctl,
 	.open		= gen_rtc_open,
 	.release	= gen_rtc_release,
 };
 static struct miscdevice rtc_gen_dev =
 {
 	.minor		= RTC_MINOR,
 	.name		= "rtc",
 	.fops		= &gen_rtc_fops,
 };
 static int __init rtc_generic_init(void)
 {
 	int retval;
 	printk(KERN_INFO "Generic RTC Driver v%s\n", RTC_VERSION);
 	retval = misc_register(&rtc_gen_dev);
 	if (retval < 0)
 		return retval;
 	retval = gen_rtc_proc_init();
 	if (retval) {
 		misc_deregister(&rtc_gen_dev);
 		return retval;
 	}
 	return 0;
 }
 static void __exit rtc_generic_exit(void)
 {
 	remove_proc_entry ("driver/rtc", NULL);
 	misc_deregister(&rtc_gen_dev);
 }
 module_init(rtc_generic_init);
 module_exit(rtc_generic_exit);
 MODULE_AUTHOR("Richard Zidlicky");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(RTC_MINOR);

drivers/char/rtc.c

Diff comments View file @ 86ae13b

 /*
  *	Real Time Clock interface for Linux
  *
  *	Copyright (C) 1996 Paul Gortmaker
  *
  *	This driver allows use of the real time clock (built into
  *	nearly all computers) from user space. It exports the /dev/rtc
  *	interface supporting various ioctl() and also the
  *	/proc/driver/rtc pseudo-file for status information.
  *
  *	The ioctls can be used to set the interrupt behaviour and
  *	generation rate from the RTC via IRQ 8. Then the /dev/rtc
  *	interface can be used to make use of these timer interrupts,
  *	be they interval or alarm based.
  *
  *	The /dev/rtc interface will block on reads until an interrupt
  *	has been received. If a RTC interrupt has already happened,
  *	it will output an unsigned long and then block. The output value
  *	contains the interrupt status in the low byte and the number of
  *	interrupts since the last read in the remaining high bytes. The
  *	/dev/rtc interface can also be used with the select(2) call.
  *
  *	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.
  *
  *	Based on other minimal char device drivers, like Alan's
  *	watchdog, Ted's random, etc. etc.
  *
  *	1.07	Paul Gortmaker.
  *	1.08	Miquel van Smoorenburg: disallow certain things on the
  *		DEC Alpha as the CMOS clock is also used for other things.
  *	1.09	Nikita Schmidt: epoch support and some Alpha cleanup.
  *	1.09a	Pete Zaitcev: Sun SPARC
  *	1.09b	Jeff Garzik: Modularize, init cleanup
  *	1.09c	Jeff Garzik: SMP cleanup
  *	1.10	Paul Barton-Davis: add support for async I/O
  *	1.10a	Andrea Arcangeli: Alpha updates
  *	1.10b	Andrew Morton: SMP lock fix
  *	1.10c	Cesar Barros: SMP locking fixes and cleanup
  *	1.10d	Paul Gortmaker: delete paranoia check in rtc_exit
  *	1.10e	Maciej W. Rozycki: Handle DECstation's year weirdness.
  *	1.11	Takashi Iwai: Kernel access functions
  *			      rtc_register/rtc_unregister/rtc_control
  *      1.11a   Daniele Bellucci: Audit create_proc_read_entry in rtc_init
  *	1.12	Venkatesh Pallipadi: Hooks for emulating rtc on HPET base-timer
  *		CONFIG_HPET_EMULATE_RTC
  *	1.12a	Maciej W. Rozycki: Handle memory-mapped chips properly.
  *	1.12ac	Alan Cox: Allow read access to the day of week register
  *	1.12b	David John: Remove calls to the BKL.
  */
 #define RTC_VERSION		"1.12b"
 /*
  *	Note that *all* calls to CMOS_READ and CMOS_WRITE are done with
  *	interrupts disabled. Due to the index-port/data-port (0x70/0x71)
  *	design of the RTC, we don't want two different things trying to
  *	get to it at once. (e.g. the periodic 11 min sync from time.c vs.
  *	this driver.)
  */
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/miscdevice.h>
 #include <linux/ioport.h>
 #include <linux/fcntl.h>
 #include <linux/mc146818rtc.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/spinlock.h>
+#include <linux/sched.h>
 #include <linux/sysctl.h>
 #include <linux/wait.h>
 #include <linux/bcd.h>
 #include <linux/delay.h>
 #include <linux/uaccess.h>
 #include <asm/current.h>
 #include <asm/system.h>
 #ifdef CONFIG_X86
 #include <asm/hpet.h>
 #endif
 #ifdef CONFIG_SPARC32
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <asm/io.h>
 static unsigned long rtc_port;
 static int rtc_irq;
 #endif
 #ifdef	CONFIG_HPET_EMULATE_RTC
 #undef	RTC_IRQ
 #endif
 #ifdef RTC_IRQ
 static int rtc_has_irq = 1;
 #endif
 #ifndef CONFIG_HPET_EMULATE_RTC
 #define is_hpet_enabled()			0
 #define hpet_set_alarm_time(hrs, min, sec)	0
 #define hpet_set_periodic_freq(arg)		0
 #define hpet_mask_rtc_irq_bit(arg)		0
 #define hpet_set_rtc_irq_bit(arg)		0
 #define hpet_rtc_timer_init()			do { } while (0)
 #define hpet_rtc_dropped_irq()			0
 #define hpet_register_irq_handler(h)		({ 0; })
 #define hpet_unregister_irq_handler(h)		({ 0; })
 #ifdef RTC_IRQ
 static irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
 {
 	return 0;
 }
 #endif
 #endif
 /*
  *	We sponge a minor off of the misc major. No need slurping
  *	up another valuable major dev number for this. If you add
  *	an ioctl, make sure you don't conflict with SPARC's RTC
  *	ioctls.
  */
 static struct fasync_struct *rtc_async_queue;
 static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);
 #ifdef RTC_IRQ
 static void rtc_dropped_irq(unsigned long data);
 static DEFINE_TIMER(rtc_irq_timer, rtc_dropped_irq, 0, 0);
 #endif
 static ssize_t rtc_read(struct file *file, char __user *buf,
 			size_t count, loff_t *ppos);
 static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 static void rtc_get_rtc_time(struct rtc_time *rtc_tm);
 #ifdef RTC_IRQ
 static unsigned int rtc_poll(struct file *file, poll_table *wait);
 #endif
 static void get_rtc_alm_time(struct rtc_time *alm_tm);
 #ifdef RTC_IRQ
 static void set_rtc_irq_bit_locked(unsigned char bit);
 static void mask_rtc_irq_bit_locked(unsigned char bit);
 static inline void set_rtc_irq_bit(unsigned char bit)
 {
 	spin_lock_irq(&rtc_lock);
 	set_rtc_irq_bit_locked(bit);
 	spin_unlock_irq(&rtc_lock);
 }
 static void mask_rtc_irq_bit(unsigned char bit)
 {
 	spin_lock_irq(&rtc_lock);
 	mask_rtc_irq_bit_locked(bit);
 	spin_unlock_irq(&rtc_lock);
 }
 #endif
 #ifdef CONFIG_PROC_FS
 static int rtc_proc_open(struct inode *inode, struct file *file);
 #endif
 /*
  *	Bits in rtc_status. (6 bits of room for future expansion)
  */
 #define RTC_IS_OPEN		0x01	/* means /dev/rtc is in use	*/
 #define RTC_TIMER_ON		0x02	/* missed irq timer active	*/
 /*
  * rtc_status is never changed by rtc_interrupt, and ioctl/open/close is
  * protected by the spin lock rtc_lock. However, ioctl can still disable the
  * timer in rtc_status and then with del_timer after the interrupt has read
  * rtc_status but before mod_timer is called, which would then reenable the
  * timer (but you would need to have an awful timing before you'd trip on it)
  */
 static unsigned long rtc_status;	/* bitmapped status byte.	*/
 static unsigned long rtc_freq;		/* Current periodic IRQ rate	*/
 static unsigned long rtc_irq_data;	/* our output to the world	*/
 static unsigned long rtc_max_user_freq = 64; /* > this, need CAP_SYS_RESOURCE */
 #ifdef RTC_IRQ
 /*
  * rtc_task_lock nests inside rtc_lock.
  */
 static DEFINE_SPINLOCK(rtc_task_lock);
 static rtc_task_t *rtc_callback;
 #endif
 /*
  *	If this driver ever becomes modularised, it will be really nice
  *	to make the epoch retain its value across module reload...
  */
 static unsigned long epoch = 1900;	/* year corresponding to 0x00	*/
 static const unsigned char days_in_mo[] =
 {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 /*
  * Returns true if a clock update is in progress
  */
 static inline unsigned char rtc_is_updating(void)
 {
 	unsigned long flags;
 	unsigned char uip;
 	spin_lock_irqsave(&rtc_lock, flags);
 	uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	return uip;
 }
 #ifdef RTC_IRQ
 /*
  *	A very tiny interrupt handler. It runs with IRQF_DISABLED set,
  *	but there is possibility of conflicting with the set_rtc_mmss()
  *	call (the rtc irq and the timer irq can easily run at the same
  *	time in two different CPUs). So we need to serialize
  *	accesses to the chip with the rtc_lock spinlock that each
  *	architecture should implement in the timer code.
  *	(See ./arch/XXXX/kernel/time.c for the set_rtc_mmss() function.)
  */
 static irqreturn_t rtc_interrupt(int irq, void *dev_id)
 {
 	/*
 	 *	Can be an alarm interrupt, update complete interrupt,
 	 *	or a periodic interrupt. We store the status in the
 	 *	low byte and the number of interrupts received since
 	 *	the last read in the remainder of rtc_irq_data.
 	 */
 	spin_lock(&rtc_lock);
 	rtc_irq_data += 0x100;
 	rtc_irq_data &= ~0xff;
 	if (is_hpet_enabled()) {
 		/*
 		 * In this case it is HPET RTC interrupt handler
 		 * calling us, with the interrupt information
 		 * passed as arg1, instead of irq.
 		 */
 		rtc_irq_data |= (unsigned long)irq & 0xF0;
 	} else {
 		rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
 	}
 	if (rtc_status & RTC_TIMER_ON)
 		mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
 	spin_unlock(&rtc_lock);
 	/* Now do the rest of the actions */
 	spin_lock(&rtc_task_lock);
 	if (rtc_callback)
 		rtc_callback->func(rtc_callback->private_data);
 	spin_unlock(&rtc_task_lock);
 	wake_up_interruptible(&rtc_wait);
 	kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
 	return IRQ_HANDLED;
 }
 #endif
 /*
  * sysctl-tuning infrastructure.
  */
 static ctl_table rtc_table[] = {
 	{
 		.ctl_name	= CTL_UNNUMBERED,
 		.procname	= "max-user-freq",
 		.data		= &rtc_max_user_freq,
 		.maxlen		= sizeof(int),
 		.mode		= 0644,
 		.proc_handler	= &proc_dointvec,
 	},
 	{ .ctl_name = 0 }
 };
 static ctl_table rtc_root[] = {
 	{
 		.ctl_name	= CTL_UNNUMBERED,
 		.procname	= "rtc",
 		.mode		= 0555,
 		.child		= rtc_table,
 	},
 	{ .ctl_name = 0 }
 };
 static ctl_table dev_root[] = {
 	{
 		.ctl_name	= CTL_DEV,
 		.procname	= "dev",
 		.mode		= 0555,
 		.child		= rtc_root,
 	},
 	{ .ctl_name = 0 }
 };
 static struct ctl_table_header *sysctl_header;
 static int __init init_sysctl(void)
 {
     sysctl_header = register_sysctl_table(dev_root);
     return 0;
 }
 static void __exit cleanup_sysctl(void)
 {
     unregister_sysctl_table(sysctl_header);
 }
 /*
  *	Now all the various file operations that we export.
  */
 static ssize_t rtc_read(struct file *file, char __user *buf,
 			size_t count, loff_t *ppos)
 {
 #ifndef RTC_IRQ
 	return -EIO;
 #else
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long data;
 	ssize_t retval;
 	if (rtc_has_irq == 0)
 		return -EIO;
 	/*
 	 * Historically this function used to assume that sizeof(unsigned long)
 	 * is the same in userspace and kernelspace.  This lead to problems
 	 * for configurations with multiple ABIs such a the MIPS o32 and 64
 	 * ABIs supported on the same kernel.  So now we support read of both
 	 * 4 and 8 bytes and assume that's the sizeof(unsigned long) in the
 	 * userspace ABI.
 	 */
 	if (count != sizeof(unsigned int) && count !=  sizeof(unsigned long))
 		return -EINVAL;
 	add_wait_queue(&rtc_wait, &wait);
 	do {
 		/* First make it right. Then make it fast. Putting this whole
 		 * block within the parentheses of a while would be too
 		 * confusing. And no, xchg() is not the answer. */
 		__set_current_state(TASK_INTERRUPTIBLE);
 		spin_lock_irq(&rtc_lock);
 		data = rtc_irq_data;
 		rtc_irq_data = 0;
 		spin_unlock_irq(&rtc_lock);
 		if (data != 0)
 			break;
 		if (file->f_flags & O_NONBLOCK) {
 			retval = -EAGAIN;
 			goto out;
 		}
 		if (signal_pending(current)) {
 			retval = -ERESTARTSYS;
 			goto out;
 		}
 		schedule();
 	} while (1);
 	if (count == sizeof(unsigned int)) {
 		retval = put_user(data,
 				  (unsigned int __user *)buf) ?: sizeof(int);
 	} else {
 		retval = put_user(data,
 				  (unsigned long __user *)buf) ?: sizeof(long);
 	}
 	if (!retval)
 		retval = count;
  out:
 	__set_current_state(TASK_RUNNING);
 	remove_wait_queue(&rtc_wait, &wait);
 	return retval;
 #endif
 }
 static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
 {
 	struct rtc_time wtime;
 #ifdef RTC_IRQ
 	if (rtc_has_irq == 0) {
 		switch (cmd) {
 		case RTC_AIE_OFF:
 		case RTC_AIE_ON:
 		case RTC_PIE_OFF:
 		case RTC_PIE_ON:
 		case RTC_UIE_OFF:
 		case RTC_UIE_ON:
 		case RTC_IRQP_READ:
 		case RTC_IRQP_SET:
 			return -EINVAL;
 		};
 	}
 #endif
 	switch (cmd) {
 #ifdef RTC_IRQ
 	case RTC_AIE_OFF:	/* Mask alarm int. enab. bit	*/
 	{
 		mask_rtc_irq_bit(RTC_AIE);
 		return 0;
 	}
 	case RTC_AIE_ON:	/* Allow alarm interrupts.	*/
 	{
 		set_rtc_irq_bit(RTC_AIE);
 		return 0;
 	}
 	case RTC_PIE_OFF:	/* Mask periodic int. enab. bit	*/
 	{
 		/* can be called from isr via rtc_control() */
 		unsigned long flags;
 		spin_lock_irqsave(&rtc_lock, flags);
 		mask_rtc_irq_bit_locked(RTC_PIE);
 		if (rtc_status & RTC_TIMER_ON) {
 			rtc_status &= ~RTC_TIMER_ON;
 			del_timer(&rtc_irq_timer);
 		}
 		spin_unlock_irqrestore(&rtc_lock, flags);
 		return 0;
 	}
 	case RTC_PIE_ON:	/* Allow periodic ints		*/
 	{
 		/* can be called from isr via rtc_control() */
 		unsigned long flags;
 		/*
 		 * We don't really want Joe User enabling more
 		 * than 64Hz of interrupts on a multi-user machine.
 		 */
 		if (!kernel && (rtc_freq > rtc_max_user_freq) &&
 						(!capable(CAP_SYS_RESOURCE)))
 			return -EACCES;
 		spin_lock_irqsave(&rtc_lock, flags);
 		if (!(rtc_status & RTC_TIMER_ON)) {
 			mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq +
 					2*HZ/100);
 			rtc_status |= RTC_TIMER_ON;
 		}
 		set_rtc_irq_bit_locked(RTC_PIE);
 		spin_unlock_irqrestore(&rtc_lock, flags);
 		return 0;
 	}
 	case RTC_UIE_OFF:	/* Mask ints from RTC updates.	*/
 	{
 		mask_rtc_irq_bit(RTC_UIE);
 		return 0;
 	}
 	case RTC_UIE_ON:	/* Allow ints for RTC updates.	*/
 	{
 		set_rtc_irq_bit(RTC_UIE);
 		return 0;
 	}
 #endif
 	case RTC_ALM_READ:	/* Read the present alarm time */
 	{
 		/*
 		 * This returns a struct rtc_time. Reading >= 0xc0
 		 * means "don't care" or "match all". Only the tm_hour,
 		 * tm_min, and tm_sec values are filled in.
 		 */
 		memset(&wtime, 0, sizeof(struct rtc_time));
 		get_rtc_alm_time(&wtime);
 		break;
 	}
 	case RTC_ALM_SET:	/* Store a time into the alarm */
 	{
 		/*
 		 * This expects a struct rtc_time. Writing 0xff means
 		 * "don't care" or "match all". Only the tm_hour,
 		 * tm_min and tm_sec are used.
 		 */
 		unsigned char hrs, min, sec;
 		struct rtc_time alm_tm;
 		if (copy_from_user(&alm_tm, (struct rtc_time __user *)arg,
 				   sizeof(struct rtc_time)))
 			return -EFAULT;
 		hrs = alm_tm.tm_hour;
 		min = alm_tm.tm_min;
 		sec = alm_tm.tm_sec;
 		spin_lock_irq(&rtc_lock);
 		if (hpet_set_alarm_time(hrs, min, sec)) {
 			/*
 			 * Fallthru and set alarm time in CMOS too,
 			 * so that we will get proper value in RTC_ALM_READ
 			 */
 		}
 		if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
 							RTC_ALWAYS_BCD) {
 			if (sec < 60)
 				sec = bin2bcd(sec);
 			else
 				sec = 0xff;
 			if (min < 60)
 				min = bin2bcd(min);
 			else
 				min = 0xff;
 			if (hrs < 24)
 				hrs = bin2bcd(hrs);
 			else
 				hrs = 0xff;
 		}
 		CMOS_WRITE(hrs, RTC_HOURS_ALARM);
 		CMOS_WRITE(min, RTC_MINUTES_ALARM);
 		CMOS_WRITE(sec, RTC_SECONDS_ALARM);
 		spin_unlock_irq(&rtc_lock);
 		return 0;
 	}
 	case RTC_RD_TIME:	/* Read the time/date from RTC	*/
 	{
 		memset(&wtime, 0, sizeof(struct rtc_time));
 		rtc_get_rtc_time(&wtime);
 		break;
 	}
 	case RTC_SET_TIME:	/* Set the RTC */
 	{
 		struct rtc_time rtc_tm;
 		unsigned char mon, day, hrs, min, sec, leap_yr;
 		unsigned char save_control, save_freq_select;
 		unsigned int yrs;
 #ifdef CONFIG_MACH_DECSTATION
 		unsigned int real_yrs;
 #endif
 		if (!capable(CAP_SYS_TIME))
 			return -EACCES;
 		if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
 				   sizeof(struct rtc_time)))
 			return -EFAULT;
 		yrs = rtc_tm.tm_year + 1900;
 		mon = rtc_tm.tm_mon + 1;   /* tm_mon starts at zero */
 		day = rtc_tm.tm_mday;
 		hrs = rtc_tm.tm_hour;
 		min = rtc_tm.tm_min;
 		sec = rtc_tm.tm_sec;
 		if (yrs < 1970)
 			return -EINVAL;
 		leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
 		if ((mon > 12) || (day == 0))
 			return -EINVAL;
 		if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
 			return -EINVAL;
 		if ((hrs >= 24) || (min >= 60) || (sec >= 60))
 			return -EINVAL;
 		yrs -= epoch;
 		if (yrs > 255)		/* They are unsigned */
 			return -EINVAL;
 		spin_lock_irq(&rtc_lock);
 #ifdef CONFIG_MACH_DECSTATION
 		real_yrs = yrs;
 		yrs = 72;
 		/*
 		 * We want to keep the year set to 73 until March
 		 * for non-leap years, so that Feb, 29th is handled
 		 * correctly.
 		 */
 		if (!leap_yr && mon < 3) {
 			real_yrs--;
 			yrs = 73;
 		}
 #endif
 		/* These limits and adjustments are independent of
 		 * whether the chip is in binary mode or not.
 		 */
 		if (yrs > 169) {
 			spin_unlock_irq(&rtc_lock);
 			return -EINVAL;
 		}
 		if (yrs >= 100)
 			yrs -= 100;
 		if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
 		    || RTC_ALWAYS_BCD) {
 			sec = bin2bcd(sec);
 			min = bin2bcd(min);
 			hrs = bin2bcd(hrs);
 			day = bin2bcd(day);
 			mon = bin2bcd(mon);
 			yrs = bin2bcd(yrs);
 		}
 		save_control = CMOS_READ(RTC_CONTROL);
 		CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
 		save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
 		CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
 #ifdef CONFIG_MACH_DECSTATION
 		CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
 #endif
 		CMOS_WRITE(yrs, RTC_YEAR);
 		CMOS_WRITE(mon, RTC_MONTH);
 		CMOS_WRITE(day, RTC_DAY_OF_MONTH);
 		CMOS_WRITE(hrs, RTC_HOURS);
 		CMOS_WRITE(min, RTC_MINUTES);
 		CMOS_WRITE(sec, RTC_SECONDS);
 		CMOS_WRITE(save_control, RTC_CONTROL);
 		CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
 		spin_unlock_irq(&rtc_lock);
 		return 0;
 	}
 #ifdef RTC_IRQ
 	case RTC_IRQP_READ:	/* Read the periodic IRQ rate.	*/
 	{
 		return put_user(rtc_freq, (unsigned long __user *)arg);
 	}
 	case RTC_IRQP_SET:	/* Set periodic IRQ rate.	*/
 	{
 		int tmp = 0;
 		unsigned char val;
 		/* can be called from isr via rtc_control() */
 		unsigned long flags;
 		/*
 		 * The max we can do is 8192Hz.
 		 */
 		if ((arg < 2) || (arg > 8192))
 			return -EINVAL;
 		/*
 		 * We don't really want Joe User generating more
 		 * than 64Hz of interrupts on a multi-user machine.
 		 */
 		if (!kernel && (arg > rtc_max_user_freq) &&
 					!capable(CAP_SYS_RESOURCE))
 			return -EACCES;
 		while (arg > (1<<tmp))
 			tmp++;
 		/*
 		 * Check that the input was really a power of 2.
 		 */
 		if (arg != (1<<tmp))
 			return -EINVAL;
 		rtc_freq = arg;
 		spin_lock_irqsave(&rtc_lock, flags);
 		if (hpet_set_periodic_freq(arg)) {
 			spin_unlock_irqrestore(&rtc_lock, flags);
 			return 0;
 		}
 		val = CMOS_READ(RTC_FREQ_SELECT) & 0xf0;
 		val |= (16 - tmp);
 		CMOS_WRITE(val, RTC_FREQ_SELECT);
 		spin_unlock_irqrestore(&rtc_lock, flags);
 		return 0;
 	}
 #endif
 	case RTC_EPOCH_READ:	/* Read the epoch.	*/
 	{
 		return put_user(epoch, (unsigned long __user *)arg);
 	}
 	case RTC_EPOCH_SET:	/* Set the epoch.	*/
 	{
 		/*
 		 * There were no RTC clocks before 1900.
 		 */
 		if (arg < 1900)
 			return -EINVAL;
 		if (!capable(CAP_SYS_TIME))
 			return -EACCES;
 		epoch = arg;
 		return 0;
 	}
 	default:
 		return -ENOTTY;
 	}
 	return copy_to_user((void __user *)arg,
 			    &wtime, sizeof wtime) ? -EFAULT : 0;
 }
 static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	long ret;
 	ret = rtc_do_ioctl(cmd, arg, 0);
 	return ret;
 }
 /*
  *	We enforce only one user at a time here with the open/close.
  *	Also clear the previous interrupt data on an open, and clean
  *	up things on a close.
  */
 static int rtc_open(struct inode *inode, struct file *file)
 {
 	spin_lock_irq(&rtc_lock);
 	if (rtc_status & RTC_IS_OPEN)
 		goto out_busy;
 	rtc_status |= RTC_IS_OPEN;
 	rtc_irq_data = 0;
 	spin_unlock_irq(&rtc_lock);
 	return 0;
 out_busy:
 	spin_unlock_irq(&rtc_lock);
 	return -EBUSY;
 }
 static int rtc_fasync(int fd, struct file *filp, int on)
 {
 	return fasync_helper(fd, filp, on, &rtc_async_queue);
 }
 static int rtc_release(struct inode *inode, struct file *file)
 {
 #ifdef RTC_IRQ
 	unsigned char tmp;
 	if (rtc_has_irq == 0)
 		goto no_irq;
 	/*
 	 * Turn off all interrupts once the device is no longer
 	 * in use, and clear the data.
 	 */
 	spin_lock_irq(&rtc_lock);
 	if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
 		tmp = CMOS_READ(RTC_CONTROL);
 		tmp &=  ~RTC_PIE;
 		tmp &=  ~RTC_AIE;
 		tmp &=  ~RTC_UIE;
 		CMOS_WRITE(tmp, RTC_CONTROL);
 		CMOS_READ(RTC_INTR_FLAGS);
 	}
 	if (rtc_status & RTC_TIMER_ON) {
 		rtc_status &= ~RTC_TIMER_ON;
 		del_timer(&rtc_irq_timer);
 	}
 	spin_unlock_irq(&rtc_lock);
 no_irq:
 #endif
 	spin_lock_irq(&rtc_lock);
 	rtc_irq_data = 0;
 	rtc_status &= ~RTC_IS_OPEN;
 	spin_unlock_irq(&rtc_lock);
 	return 0;
 }
 #ifdef RTC_IRQ
 static unsigned int rtc_poll(struct file *file, poll_table *wait)
 {
 	unsigned long l;
 	if (rtc_has_irq == 0)
 		return 0;
 	poll_wait(file, &rtc_wait, wait);
 	spin_lock_irq(&rtc_lock);
 	l = rtc_irq_data;
 	spin_unlock_irq(&rtc_lock);
 	if (l != 0)
 		return POLLIN | POLLRDNORM;
 	return 0;
 }
 #endif
 int rtc_register(rtc_task_t *task)
 {
 #ifndef RTC_IRQ
 	return -EIO;
 #else
 	if (task == NULL || task->func == NULL)
 		return -EINVAL;
 	spin_lock_irq(&rtc_lock);
 	if (rtc_status & RTC_IS_OPEN) {
 		spin_unlock_irq(&rtc_lock);
 		return -EBUSY;
 	}
 	spin_lock(&rtc_task_lock);
 	if (rtc_callback) {
 		spin_unlock(&rtc_task_lock);
 		spin_unlock_irq(&rtc_lock);
 		return -EBUSY;
 	}
 	rtc_status |= RTC_IS_OPEN;
 	rtc_callback = task;
 	spin_unlock(&rtc_task_lock);
 	spin_unlock_irq(&rtc_lock);
 	return 0;
 #endif
 }
 EXPORT_SYMBOL(rtc_register);
 int rtc_unregister(rtc_task_t *task)
 {
 #ifndef RTC_IRQ
 	return -EIO;
 #else
 	unsigned char tmp;
 	spin_lock_irq(&rtc_lock);
 	spin_lock(&rtc_task_lock);
 	if (rtc_callback != task) {
 		spin_unlock(&rtc_task_lock);
 		spin_unlock_irq(&rtc_lock);
 		return -ENXIO;
 	}
 	rtc_callback = NULL;
 	/* disable controls */
 	if (!hpet_mask_rtc_irq_bit(RTC_PIE | RTC_AIE | RTC_UIE)) {
 		tmp = CMOS_READ(RTC_CONTROL);
 		tmp &= ~RTC_PIE;
 		tmp &= ~RTC_AIE;
 		tmp &= ~RTC_UIE;
 		CMOS_WRITE(tmp, RTC_CONTROL);
 		CMOS_READ(RTC_INTR_FLAGS);
 	}
 	if (rtc_status & RTC_TIMER_ON) {
 		rtc_status &= ~RTC_TIMER_ON;
 		del_timer(&rtc_irq_timer);
 	}
 	rtc_status &= ~RTC_IS_OPEN;
 	spin_unlock(&rtc_task_lock);
 	spin_unlock_irq(&rtc_lock);
 	return 0;
 #endif
 }
 EXPORT_SYMBOL(rtc_unregister);
 int rtc_control(rtc_task_t *task, unsigned int cmd, unsigned long arg)
 {
 #ifndef RTC_IRQ
 	return -EIO;
 #else
 	unsigned long flags;
 	if (cmd != RTC_PIE_ON && cmd != RTC_PIE_OFF && cmd != RTC_IRQP_SET)
 		return -EINVAL;
 	spin_lock_irqsave(&rtc_task_lock, flags);
 	if (rtc_callback != task) {
 		spin_unlock_irqrestore(&rtc_task_lock, flags);
 		return -ENXIO;
 	}
 	spin_unlock_irqrestore(&rtc_task_lock, flags);
 	return rtc_do_ioctl(cmd, arg, 1);
 #endif
 }
 EXPORT_SYMBOL(rtc_control);
 /*
  *	The various file operations we support.
  */
 static const struct file_operations rtc_fops = {
 	.owner		= THIS_MODULE,
 	.llseek		= no_llseek,
 	.read		= rtc_read,
 #ifdef RTC_IRQ
 	.poll		= rtc_poll,
 #endif
 	.unlocked_ioctl	= rtc_ioctl,
 	.open		= rtc_open,
 	.release	= rtc_release,
 	.fasync		= rtc_fasync,
 };
 static struct miscdevice rtc_dev = {
 	.minor		= RTC_MINOR,
 	.name		= "rtc",
 	.fops		= &rtc_fops,
 };
 #ifdef CONFIG_PROC_FS
 static const struct file_operations rtc_proc_fops = {
 	.owner		= THIS_MODULE,
 	.open		= rtc_proc_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= single_release,
 };
 #endif
 static resource_size_t rtc_size;
 static struct resource * __init rtc_request_region(resource_size_t size)
 {
 	struct resource *r;
 	if (RTC_IOMAPPED)
 		r = request_region(RTC_PORT(0), size, "rtc");
 	else
 		r = request_mem_region(RTC_PORT(0), size, "rtc");
 	if (r)
 		rtc_size = size;
 	return r;
 }
 static void rtc_release_region(void)
 {
 	if (RTC_IOMAPPED)
 		release_region(RTC_PORT(0), rtc_size);
 	else
 		release_mem_region(RTC_PORT(0), rtc_size);
 }
 static int __init rtc_init(void)
 {
 #ifdef CONFIG_PROC_FS
 	struct proc_dir_entry *ent;
 #endif
 #if defined(__alpha__) || defined(__mips__)
 	unsigned int year, ctrl;
 	char *guess = NULL;
 #endif
 #ifdef CONFIG_SPARC32
 	struct device_node *ebus_dp;
 	struct of_device *op;
 #else
 	void *r;
 #ifdef RTC_IRQ
 	irq_handler_t rtc_int_handler_ptr;
 #endif
 #endif
 #ifdef CONFIG_SPARC32
 	for_each_node_by_name(ebus_dp, "ebus") {
 		struct device_node *dp;
 		for (dp = ebus_dp; dp; dp = dp->sibling) {
 			if (!strcmp(dp->name, "rtc")) {
 				op = of_find_device_by_node(dp);
 				if (op) {
 					rtc_port = op->resource[0].start;
 					rtc_irq = op->irqs[0];
 					goto found;
 				}
 			}
 		}
 	}
 	rtc_has_irq = 0;
 	printk(KERN_ERR "rtc_init: no PC rtc found\n");
 	return -EIO;
 found:
 	if (!rtc_irq) {
 		rtc_has_irq = 0;
 		goto no_irq;
 	}
 	/*
 	 * XXX Interrupt pin #7 in Espresso is shared between RTC and
 	 * PCI Slot 2 INTA# (and some INTx# in Slot 1).
 	 */
 	if (request_irq(rtc_irq, rtc_interrupt, IRQF_SHARED, "rtc",
 			(void *)&rtc_port)) {
 		rtc_has_irq = 0;
 		printk(KERN_ERR "rtc: cannot register IRQ %d\n", rtc_irq);
 		return -EIO;
 	}
 no_irq:
 #else
 	r = rtc_request_region(RTC_IO_EXTENT);
 	/*
 	 * If we've already requested a smaller range (for example, because
 	 * PNPBIOS or ACPI told us how the device is configured), the request
 	 * above might fail because it's too big.
 	 *
 	 * If so, request just the range we actually use.
 	 */
 	if (!r)
 		r = rtc_request_region(RTC_IO_EXTENT_USED);
 	if (!r) {
 #ifdef RTC_IRQ
 		rtc_has_irq = 0;
 #endif
 		printk(KERN_ERR "rtc: I/O resource %lx is not free.\n",
 		       (long)(RTC_PORT(0)));
 		return -EIO;
 	}
 #ifdef RTC_IRQ
 	if (is_hpet_enabled()) {
 		int err;
 		rtc_int_handler_ptr = hpet_rtc_interrupt;
 		err = hpet_register_irq_handler(rtc_interrupt);
 		if (err != 0) {
 			printk(KERN_WARNING "hpet_register_irq_handler failed "
 					"in rtc_init().");
 			return err;
 		}
 	} else {
 		rtc_int_handler_ptr = rtc_interrupt;
 	}
 	if (request_irq(RTC_IRQ, rtc_int_handler_ptr, IRQF_DISABLED,
 			"rtc", NULL)) {
 		/* Yeah right, seeing as irq 8 doesn't even hit the bus. */
 		rtc_has_irq = 0;
 		printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
 		rtc_release_region();
 		return -EIO;
 	}
 	hpet_rtc_timer_init();
 #endif
 #endif /* CONFIG_SPARC32 vs. others */
 	if (misc_register(&rtc_dev)) {
 #ifdef RTC_IRQ
 		free_irq(RTC_IRQ, NULL);
 		hpet_unregister_irq_handler(rtc_interrupt);
 		rtc_has_irq = 0;
 #endif
 		rtc_release_region();
 		return -ENODEV;
 	}
 #ifdef CONFIG_PROC_FS
 	ent = proc_create("driver/rtc", 0, NULL, &rtc_proc_fops);
 	if (!ent)
 		printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
 #endif
 #if defined(__alpha__) || defined(__mips__)
 	rtc_freq = HZ;
 	/* Each operating system on an Alpha uses its own epoch.
 	   Let's try to guess which one we are using now. */
 	if (rtc_is_updating() != 0)
 		msleep(20);
 	spin_lock_irq(&rtc_lock);
 	year = CMOS_READ(RTC_YEAR);
 	ctrl = CMOS_READ(RTC_CONTROL);
 	spin_unlock_irq(&rtc_lock);
 	if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
 		year = bcd2bin(year);       /* This should never happen... */
 	if (year < 20) {
 		epoch = 2000;
 		guess = "SRM (post-2000)";
 	} else if (year >= 20 && year < 48) {
 		epoch = 1980;
 		guess = "ARC console";
 	} else if (year >= 48 && year < 72) {
 		epoch = 1952;
 		guess = "Digital UNIX";
 #if defined(__mips__)
 	} else if (year >= 72 && year < 74) {
 		epoch = 2000;
 		guess = "Digital DECstation";
 #else
 	} else if (year >= 70) {
 		epoch = 1900;
 		guess = "Standard PC (1900)";
 #endif
 	}
 	if (guess)
 		printk(KERN_INFO "rtc: %s epoch (%lu) detected\n",
 			guess, epoch);
 #endif
 #ifdef RTC_IRQ
 	if (rtc_has_irq == 0)
 		goto no_irq2;
 	spin_lock_irq(&rtc_lock);
 	rtc_freq = 1024;
 	if (!hpet_set_periodic_freq(rtc_freq)) {
 		/*
 		 * Initialize periodic frequency to CMOS reset default,
 		 * which is 1024Hz
 		 */
 		CMOS_WRITE(((CMOS_READ(RTC_FREQ_SELECT) & 0xF0) | 0x06),
 			   RTC_FREQ_SELECT);
 	}
 	spin_unlock_irq(&rtc_lock);
 no_irq2:
 #endif
 	(void) init_sysctl();
 	printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
 	return 0;
 }
 static void __exit rtc_exit(void)
 {
 	cleanup_sysctl();
 	remove_proc_entry("driver/rtc", NULL);
 	misc_deregister(&rtc_dev);
 #ifdef CONFIG_SPARC32
 	if (rtc_has_irq)
 		free_irq(rtc_irq, &rtc_port);
 #else
 	rtc_release_region();
 #ifdef RTC_IRQ
 	if (rtc_has_irq) {
 		free_irq(RTC_IRQ, NULL);
 		hpet_unregister_irq_handler(hpet_rtc_interrupt);
 	}
 #endif
 #endif /* CONFIG_SPARC32 */
 }
 module_init(rtc_init);
 module_exit(rtc_exit);
 #ifdef RTC_IRQ
 /*
  *	At IRQ rates >= 4096Hz, an interrupt may get lost altogether.
  *	(usually during an IDE disk interrupt, with IRQ unmasking off)
  *	Since the interrupt handler doesn't get called, the IRQ status
  *	byte doesn't get read, and the RTC stops generating interrupts.
  *	A timer is set, and will call this function if/when that happens.
  *	To get it out of this stalled state, we just read the status.
  *	At least a jiffy of interrupts (rtc_freq/HZ) will have been lost.
  *	(You *really* shouldn't be trying to use a non-realtime system
  *	for something that requires a steady > 1KHz signal anyways.)
  */
 static void rtc_dropped_irq(unsigned long data)
 {
 	unsigned long freq;
 	spin_lock_irq(&rtc_lock);
 	if (hpet_rtc_dropped_irq()) {
 		spin_unlock_irq(&rtc_lock);
 		return;
 	}
 	/* Just in case someone disabled the timer from behind our back... */
 	if (rtc_status & RTC_TIMER_ON)
 		mod_timer(&rtc_irq_timer, jiffies + HZ/rtc_freq + 2*HZ/100);
 	rtc_irq_data += ((rtc_freq/HZ)<<8);
 	rtc_irq_data &= ~0xff;
 	rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);	/* restart */
 	freq = rtc_freq;
 	spin_unlock_irq(&rtc_lock);
 	if (printk_ratelimit()) {
 		printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
 			freq);
 	}
 	/* Now we have new data */
 	wake_up_interruptible(&rtc_wait);
 	kill_fasync(&rtc_async_queue, SIGIO, POLL_IN);
 }
 #endif
 #ifdef CONFIG_PROC_FS
 /*
  *	Info exported via "/proc/driver/rtc".
  */
 static int rtc_proc_show(struct seq_file *seq, void *v)
 {
 #define YN(bit) ((ctrl & bit) ? "yes" : "no")
 #define NY(bit) ((ctrl & bit) ? "no" : "yes")
 	struct rtc_time tm;
 	unsigned char batt, ctrl;
 	unsigned long freq;
 	spin_lock_irq(&rtc_lock);
 	batt = CMOS_READ(RTC_VALID) & RTC_VRT;
 	ctrl = CMOS_READ(RTC_CONTROL);
 	freq = rtc_freq;
 	spin_unlock_irq(&rtc_lock);
 	rtc_get_rtc_time(&tm);
 	/*
 	 * There is no way to tell if the luser has the RTC set for local
 	 * time or for Universal Standard Time (GMT). Probably local though.
 	 */
 	seq_printf(seq,
 		   "rtc_time\t: %02d:%02d:%02d\n"
 		   "rtc_date\t: %04d-%02d-%02d\n"
 		   "rtc_epoch\t: %04lu\n",
 		   tm.tm_hour, tm.tm_min, tm.tm_sec,
 		   tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, epoch);
 	get_rtc_alm_time(&tm);
 	/*
 	 * We implicitly assume 24hr mode here. Alarm values >= 0xc0 will
 	 * match any value for that particular field. Values that are
 	 * greater than a valid time, but less than 0xc0 shouldn't appear.
 	 */
 	seq_puts(seq, "alarm\t\t: ");
 	if (tm.tm_hour <= 24)
 		seq_printf(seq, "%02d:", tm.tm_hour);
 	else
 		seq_puts(seq, "**:");
 	if (tm.tm_min <= 59)
 		seq_printf(seq, "%02d:", tm.tm_min);
 	else
 		seq_puts(seq, "**:");
 	if (tm.tm_sec <= 59)
 		seq_printf(seq, "%02d\n", tm.tm_sec);
 	else
 		seq_puts(seq, "**\n");
 	seq_printf(seq,
 		   "DST_enable\t: %s\n"
 		   "BCD\t\t: %s\n"
 		   "24hr\t\t: %s\n"
 		   "square_wave\t: %s\n"
 		   "alarm_IRQ\t: %s\n"
 		   "update_IRQ\t: %s\n"
 		   "periodic_IRQ\t: %s\n"
 		   "periodic_freq\t: %ld\n"
 		   "batt_status\t: %s\n",
 		   YN(RTC_DST_EN),
 		   NY(RTC_DM_BINARY),
 		   YN(RTC_24H),
 		   YN(RTC_SQWE),
 		   YN(RTC_AIE),
 		   YN(RTC_UIE),
 		   YN(RTC_PIE),
 		   freq,
 		   batt ? "okay" : "dead");
 	return  0;
 #undef YN
 #undef NY
 }
 static int rtc_proc_open(struct inode *inode, struct file *file)
 {
 	return single_open(file, rtc_proc_show, NULL);
 }
 #endif
 static void rtc_get_rtc_time(struct rtc_time *rtc_tm)
 {
 	unsigned long uip_watchdog = jiffies, flags;
 	unsigned char ctrl;
 #ifdef CONFIG_MACH_DECSTATION
 	unsigned int real_year;
 #endif
 	/*
 	 * read RTC once any update in progress is done. The update
 	 * can take just over 2ms. We wait 20ms. There is no need to
 	 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
 	 * If you need to know *exactly* when a second has started, enable
 	 * periodic update complete interrupts, (via ioctl) and then
 	 * immediately read /dev/rtc which will block until you get the IRQ.
 	 * Once the read clears, read the RTC time (again via ioctl). Easy.
 	 */
 	while (rtc_is_updating() != 0 &&
 	       time_before(jiffies, uip_watchdog + 2*HZ/100))
 		cpu_relax();
 	/*
 	 * Only the values that we read from the RTC are set. We leave
 	 * tm_wday, tm_yday and tm_isdst untouched. Note that while the
 	 * RTC has RTC_DAY_OF_WEEK, we should usually ignore it, as it is
 	 * only updated by the RTC when initially set to a non-zero value.
 	 */
 	spin_lock_irqsave(&rtc_lock, flags);
 	rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
 	rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
 	rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
 	rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
 	rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
 	rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
 	/* Only set from 2.6.16 onwards */
 	rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
 #ifdef CONFIG_MACH_DECSTATION
 	real_year = CMOS_READ(RTC_DEC_YEAR);
 #endif
 	ctrl = CMOS_READ(RTC_CONTROL);
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
 		rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
 		rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
 		rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
 		rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
 		rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
 		rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 		rtc_tm->tm_wday = bcd2bin(rtc_tm->tm_wday);
 	}
 #ifdef CONFIG_MACH_DECSTATION
 	rtc_tm->tm_year += real_year - 72;
 #endif
 	/*
 	 * Account for differences between how the RTC uses the values
 	 * and how they are defined in a struct rtc_time;
 	 */
 	rtc_tm->tm_year += epoch - 1900;
 	if (rtc_tm->tm_year <= 69)
 		rtc_tm->tm_year += 100;
 	rtc_tm->tm_mon--;
 }
 static void get_rtc_alm_time(struct rtc_time *alm_tm)
 {
 	unsigned char ctrl;
 	/*
 	 * Only the values that we read from the RTC are set. That
 	 * means only tm_hour, tm_min, and tm_sec.
 	 */
 	spin_lock_irq(&rtc_lock);
 	alm_tm->tm_sec = CMOS_READ(RTC_SECONDS_ALARM);
 	alm_tm->tm_min = CMOS_READ(RTC_MINUTES_ALARM);
 	alm_tm->tm_hour = CMOS_READ(RTC_HOURS_ALARM);
 	ctrl = CMOS_READ(RTC_CONTROL);
 	spin_unlock_irq(&rtc_lock);
 	if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
 		alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
 		alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
 		alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
 	}
 }
 #ifdef RTC_IRQ
 /*
  * Used to disable/enable interrupts for any one of UIE, AIE, PIE.
  * Rumour has it that if you frob the interrupt enable/disable
  * bits in RTC_CONTROL, you should read RTC_INTR_FLAGS, to
  * ensure you actually start getting interrupts. Probably for
  * compatibility with older/broken chipset RTC implementations.
  * We also clear out any old irq data after an ioctl() that
  * meddles with the interrupt enable/disable bits.
  */
 static void mask_rtc_irq_bit_locked(unsigned char bit)
 {
 	unsigned char val;
 	if (hpet_mask_rtc_irq_bit(bit))
 		return;
 	val = CMOS_READ(RTC_CONTROL);
 	val &=  ~bit;
 	CMOS_WRITE(val, RTC_CONTROL);
 	CMOS_READ(RTC_INTR_FLAGS);
 	rtc_irq_data = 0;
 }
 static void set_rtc_irq_bit_locked(unsigned char bit)
 {
 	unsigned char val;
 	if (hpet_set_rtc_irq_bit(bit))
 		return;
 	val = CMOS_READ(RTC_CONTROL);
 	val |= bit;
 	CMOS_WRITE(val, RTC_CONTROL);
 	CMOS_READ(RTC_INTR_FLAGS);
 	rtc_irq_data = 0;
 }
 #endif
 MODULE_AUTHOR("Paul Gortmaker");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(RTC_MINOR);

drivers/char/sonypi.c

Diff comments View file @ 86ae13b

 /*
  * Sony Programmable I/O Control Device driver for VAIO
  *
  * Copyright (C) 2007 Mattia Dongili <malattia@linux.it>
  *
  * Copyright (C) 2001-2005 Stelian Pop <stelian@popies.net>
  *
  * Copyright (C) 2005 Narayanan R S <nars@kadamba.org>
  *
  * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
  *
  * Copyright (C) 2001 Michael Ashley <m.ashley@unsw.edu.au>
  *
  * Copyright (C) 2001 Junichi Morita <jun1m@mars.dti.ne.jp>
  *
  * Copyright (C) 2000 Takaya Kinjo <t-kinjo@tc4.so-net.ne.jp>
  *
  * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
  *
  * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
  *
  * 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.
  *
  */
 #include <linux/module.h>
+#include <linux/sched.h>
 #include <linux/input.h>
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/miscdevice.h>
 #include <linux/poll.h>
 #include <linux/delay.h>
 #include <linux/wait.h>
 #include <linux/acpi.h>
 #include <linux/dmi.h>
 #include <linux/err.h>
 #include <linux/kfifo.h>
 #include <linux/platform_device.h>
 #include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/system.h>
 #include <linux/sonypi.h>
 #define SONYPI_DRIVER_VERSION	 "1.26"
 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
 MODULE_DESCRIPTION("Sony Programmable I/O Control Device driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(SONYPI_DRIVER_VERSION);
 static int minor = -1;
 module_param(minor, int, 0);
 MODULE_PARM_DESC(minor,
 		 "minor number of the misc device, default is -1 (automatic)");
 static int verbose;		/* = 0 */
 module_param(verbose, int, 0644);
 MODULE_PARM_DESC(verbose, "be verbose, default is 0 (no)");
 static int fnkeyinit;		/* = 0 */
 module_param(fnkeyinit, int, 0444);
 MODULE_PARM_DESC(fnkeyinit,
 		 "set this if your Fn keys do not generate any event");
 static int camera;		/* = 0 */
 module_param(camera, int, 0444);
 MODULE_PARM_DESC(camera,
 		 "set this if you have a MotionEye camera (PictureBook series)");
 static int compat;		/* = 0 */
 module_param(compat, int, 0444);
 MODULE_PARM_DESC(compat,
 		 "set this if you want to enable backward compatibility mode");
 static unsigned long mask = 0xffffffff;
 module_param(mask, ulong, 0644);
 MODULE_PARM_DESC(mask,
 		 "set this to the mask of event you want to enable (see doc)");
 static int useinput = 1;
 module_param(useinput, int, 0444);
 MODULE_PARM_DESC(useinput,
 		 "set this if you would like sonypi to feed events to the input subsystem");
 static int check_ioport = 1;
 module_param(check_ioport, int, 0444);
 MODULE_PARM_DESC(check_ioport,
 		 "set this to 0 if you think the automatic ioport check for sony-laptop is wrong");
 #define SONYPI_DEVICE_MODEL_TYPE1	1
 #define SONYPI_DEVICE_MODEL_TYPE2	2
 #define SONYPI_DEVICE_MODEL_TYPE3	3
 /* type1 models use those */
 #define SONYPI_IRQ_PORT			0x8034
 #define SONYPI_IRQ_SHIFT		22
 #define SONYPI_TYPE1_BASE		0x50
 #define SONYPI_G10A			(SONYPI_TYPE1_BASE+0x14)
 #define SONYPI_TYPE1_REGION_SIZE	0x08
 #define SONYPI_TYPE1_EVTYPE_OFFSET	0x04
 /* type2 series specifics */
 #define SONYPI_SIRQ			0x9b
 #define SONYPI_SLOB			0x9c
 #define SONYPI_SHIB			0x9d
 #define SONYPI_TYPE2_REGION_SIZE	0x20
 #define SONYPI_TYPE2_EVTYPE_OFFSET	0x12
 /* type3 series specifics */
 #define SONYPI_TYPE3_BASE		0x40
 #define SONYPI_TYPE3_GID2		(SONYPI_TYPE3_BASE+0x48) /* 16 bits */
 #define SONYPI_TYPE3_MISC		(SONYPI_TYPE3_BASE+0x6d) /* 8 bits  */
 #define SONYPI_TYPE3_REGION_SIZE	0x20
 #define SONYPI_TYPE3_EVTYPE_OFFSET	0x12
 /* battery / brightness addresses */
 #define SONYPI_BAT_FLAGS	0x81
 #define SONYPI_LCD_LIGHT	0x96
 #define SONYPI_BAT1_PCTRM	0xa0
 #define SONYPI_BAT1_LEFT	0xa2
 #define SONYPI_BAT1_MAXRT	0xa4
 #define SONYPI_BAT2_PCTRM	0xa8
 #define SONYPI_BAT2_LEFT	0xaa
 #define SONYPI_BAT2_MAXRT	0xac
 #define SONYPI_BAT1_MAXTK	0xb0
 #define SONYPI_BAT1_FULL	0xb2
 #define SONYPI_BAT2_MAXTK	0xb8
 #define SONYPI_BAT2_FULL	0xba
 /* FAN0 information (reverse engineered from ACPI tables) */
 #define SONYPI_FAN0_STATUS	0x93
 #define SONYPI_TEMP_STATUS	0xC1
 /* ioports used for brightness and type2 events */
 #define SONYPI_DATA_IOPORT	0x62
 #define SONYPI_CST_IOPORT	0x66
 /* The set of possible ioports */
 struct sonypi_ioport_list {
 	u16	port1;
 	u16	port2;
 };
 static struct sonypi_ioport_list sonypi_type1_ioport_list[] = {
 	{ 0x10c0, 0x10c4 },	/* looks like the default on C1Vx */
 	{ 0x1080, 0x1084 },
 	{ 0x1090, 0x1094 },
 	{ 0x10a0, 0x10a4 },
 	{ 0x10b0, 0x10b4 },
 	{ 0x0, 0x0 }
 };
 static struct sonypi_ioport_list sonypi_type2_ioport_list[] = {
 	{ 0x1080, 0x1084 },
 	{ 0x10a0, 0x10a4 },
 	{ 0x10c0, 0x10c4 },
 	{ 0x10e0, 0x10e4 },
 	{ 0x0, 0x0 }
 };
 /* same as in type 2 models */
 static struct sonypi_ioport_list *sonypi_type3_ioport_list =
 	sonypi_type2_ioport_list;
 /* The set of possible interrupts */
 struct sonypi_irq_list {
 	u16	irq;
 	u16	bits;
 };
 static struct sonypi_irq_list sonypi_type1_irq_list[] = {
 	{ 11, 0x2 },	/* IRQ 11, GO22=0,GO23=1 in AML */
 	{ 10, 0x1 },	/* IRQ 10, GO22=1,GO23=0 in AML */
 	{  5, 0x0 },	/* IRQ  5, GO22=0,GO23=0 in AML */
 	{  0, 0x3 }	/* no IRQ, GO22=1,GO23=1 in AML */
 };
 static struct sonypi_irq_list sonypi_type2_irq_list[] = {
 	{ 11, 0x80 },	/* IRQ 11, 0x80 in SIRQ in AML */
 	{ 10, 0x40 },	/* IRQ 10, 0x40 in SIRQ in AML */
 	{  9, 0x20 },	/* IRQ  9, 0x20 in SIRQ in AML */
 	{  6, 0x10 },	/* IRQ  6, 0x10 in SIRQ in AML */
 	{  0, 0x00 }	/* no IRQ, 0x00 in SIRQ in AML */
 };
 /* same as in type2 models */
 static struct sonypi_irq_list *sonypi_type3_irq_list = sonypi_type2_irq_list;
 #define SONYPI_CAMERA_BRIGHTNESS		0
 #define SONYPI_CAMERA_CONTRAST			1
 #define SONYPI_CAMERA_HUE			2
 #define SONYPI_CAMERA_COLOR			3
 #define SONYPI_CAMERA_SHARPNESS			4
 #define SONYPI_CAMERA_PICTURE			5
 #define SONYPI_CAMERA_EXPOSURE_MASK		0xC
 #define SONYPI_CAMERA_WHITE_BALANCE_MASK	0x3
 #define SONYPI_CAMERA_PICTURE_MODE_MASK		0x30
 #define SONYPI_CAMERA_MUTE_MASK			0x40
 /* the rest don't need a loop until not 0xff */
 #define SONYPI_CAMERA_AGC			6
 #define SONYPI_CAMERA_AGC_MASK			0x30
 #define SONYPI_CAMERA_SHUTTER_MASK 		0x7
 #define SONYPI_CAMERA_SHUTDOWN_REQUEST		7
 #define SONYPI_CAMERA_CONTROL			0x10
 #define SONYPI_CAMERA_STATUS 			7
 #define SONYPI_CAMERA_STATUS_READY 		0x2
 #define SONYPI_CAMERA_STATUS_POSITION		0x4
 #define SONYPI_DIRECTION_BACKWARDS 		0x4
 #define SONYPI_CAMERA_REVISION 			8
 #define SONYPI_CAMERA_ROMVERSION 		9
 /* Event masks */
 #define SONYPI_JOGGER_MASK			0x00000001
 #define SONYPI_CAPTURE_MASK			0x00000002
 #define SONYPI_FNKEY_MASK			0x00000004
 #define SONYPI_BLUETOOTH_MASK			0x00000008
 #define SONYPI_PKEY_MASK			0x00000010
 #define SONYPI_BACK_MASK			0x00000020
 #define SONYPI_HELP_MASK			0x00000040
 #define SONYPI_LID_MASK				0x00000080
 #define SONYPI_ZOOM_MASK			0x00000100
 #define SONYPI_THUMBPHRASE_MASK			0x00000200
 #define SONYPI_MEYE_MASK			0x00000400
 #define SONYPI_MEMORYSTICK_MASK			0x00000800
 #define SONYPI_BATTERY_MASK			0x00001000
 #define SONYPI_WIRELESS_MASK			0x00002000
 struct sonypi_event {
 	u8	data;
 	u8	event;
 };
 /* The set of possible button release events */
 static struct sonypi_event sonypi_releaseev[] = {
 	{ 0x00, SONYPI_EVENT_ANYBUTTON_RELEASED },
 	{ 0, 0 }
 };
 /* The set of possible jogger events  */
 static struct sonypi_event sonypi_joggerev[] = {
 	{ 0x1f, SONYPI_EVENT_JOGDIAL_UP },
 	{ 0x01, SONYPI_EVENT_JOGDIAL_DOWN },
 	{ 0x5f, SONYPI_EVENT_JOGDIAL_UP_PRESSED },
 	{ 0x41, SONYPI_EVENT_JOGDIAL_DOWN_PRESSED },
 	{ 0x1e, SONYPI_EVENT_JOGDIAL_FAST_UP },
 	{ 0x02, SONYPI_EVENT_JOGDIAL_FAST_DOWN },
 	{ 0x5e, SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED },
 	{ 0x42, SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED },
 	{ 0x1d, SONYPI_EVENT_JOGDIAL_VFAST_UP },
 	{ 0x03, SONYPI_EVENT_JOGDIAL_VFAST_DOWN },
 	{ 0x5d, SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED },
 	{ 0x43, SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED },
 	{ 0x40, SONYPI_EVENT_JOGDIAL_PRESSED },
 	{ 0, 0 }
 };
 /* The set of possible capture button events */
 static struct sonypi_event sonypi_captureev[] = {
 	{ 0x05, SONYPI_EVENT_CAPTURE_PARTIALPRESSED },
 	{ 0x07, SONYPI_EVENT_CAPTURE_PRESSED },
 	{ 0x01, SONYPI_EVENT_CAPTURE_PARTIALRELEASED },
 	{ 0, 0 }
 };
 /* The set of possible fnkeys events */
 static struct sonypi_event sonypi_fnkeyev[] = {
 	{ 0x10, SONYPI_EVENT_FNKEY_ESC },
 	{ 0x11, SONYPI_EVENT_FNKEY_F1 },
 	{ 0x12, SONYPI_EVENT_FNKEY_F2 },
 	{ 0x13, SONYPI_EVENT_FNKEY_F3 },
 	{ 0x14, SONYPI_EVENT_FNKEY_F4 },
 	{ 0x15, SONYPI_EVENT_FNKEY_F5 },
 	{ 0x16, SONYPI_EVENT_FNKEY_F6 },
 	{ 0x17, SONYPI_EVENT_FNKEY_F7 },
 	{ 0x18, SONYPI_EVENT_FNKEY_F8 },
 	{ 0x19, SONYPI_EVENT_FNKEY_F9 },
 	{ 0x1a, SONYPI_EVENT_FNKEY_F10 },
 	{ 0x1b, SONYPI_EVENT_FNKEY_F11 },
 	{ 0x1c, SONYPI_EVENT_FNKEY_F12 },
 	{ 0x1f, SONYPI_EVENT_FNKEY_RELEASED },
 	{ 0x21, SONYPI_EVENT_FNKEY_1 },
 	{ 0x22, SONYPI_EVENT_FNKEY_2 },
 	{ 0x31, SONYPI_EVENT_FNKEY_D },
 	{ 0x32, SONYPI_EVENT_FNKEY_E },
 	{ 0x33, SONYPI_EVENT_FNKEY_F },
 	{ 0x34, SONYPI_EVENT_FNKEY_S },
 	{ 0x35, SONYPI_EVENT_FNKEY_B },
 	{ 0x36, SONYPI_EVENT_FNKEY_ONLY },
 	{ 0, 0 }
 };
 /* The set of possible program key events */
 static struct sonypi_event sonypi_pkeyev[] = {
 	{ 0x01, SONYPI_EVENT_PKEY_P1 },
 	{ 0x02, SONYPI_EVENT_PKEY_P2 },
 	{ 0x04, SONYPI_EVENT_PKEY_P3 },
 	{ 0x5c, SONYPI_EVENT_PKEY_P1 },
 	{ 0, 0 }
 };
 /* The set of possible bluetooth events */
 static struct sonypi_event sonypi_blueev[] = {
 	{ 0x55, SONYPI_EVENT_BLUETOOTH_PRESSED },
 	{ 0x59, SONYPI_EVENT_BLUETOOTH_ON },
 	{ 0x5a, SONYPI_EVENT_BLUETOOTH_OFF },
 	{ 0, 0 }
 };
 /* The set of possible wireless events */
 static struct sonypi_event sonypi_wlessev[] = {
 	{ 0x59, SONYPI_EVENT_WIRELESS_ON },
 	{ 0x5a, SONYPI_EVENT_WIRELESS_OFF },
 	{ 0, 0 }
 };
 /* The set of possible back button events */
 static struct sonypi_event sonypi_backev[] = {
 	{ 0x20, SONYPI_EVENT_BACK_PRESSED },
 	{ 0, 0 }
 };
 /* The set of possible help button events */
 static struct sonypi_event sonypi_helpev[] = {
 	{ 0x3b, SONYPI_EVENT_HELP_PRESSED },
 	{ 0, 0 }
 };
 /* The set of possible lid events */
 static struct sonypi_event sonypi_lidev[] = {
 	{ 0x51, SONYPI_EVENT_LID_CLOSED },
 	{ 0x50, SONYPI_EVENT_LID_OPENED },
 	{ 0, 0 }
 };
 /* The set of possible zoom events */
 static struct sonypi_event sonypi_zoomev[] = {
 	{ 0x39, SONYPI_EVENT_ZOOM_PRESSED },
 	{ 0, 0 }
 };
 /* The set of possible thumbphrase events */
 static struct sonypi_event sonypi_thumbphraseev[] = {
 	{ 0x3a, SONYPI_EVENT_THUMBPHRASE_PRESSED },
 	{ 0, 0 }
 };
 /* The set of possible motioneye camera events */
 static struct sonypi_event sonypi_meyeev[] = {
 	{ 0x00, SONYPI_EVENT_MEYE_FACE },
 	{ 0x01, SONYPI_EVENT_MEYE_OPPOSITE },
 	{ 0, 0 }
 };
 /* The set of possible memorystick events */
 static struct sonypi_event sonypi_memorystickev[] = {
 	{ 0x53, SONYPI_EVENT_MEMORYSTICK_INSERT },
 	{ 0x54, SONYPI_EVENT_MEMORYSTICK_EJECT },
 	{ 0, 0 }
 };
 /* The set of possible battery events */
 static struct sonypi_event sonypi_batteryev[] = {
 	{ 0x20, SONYPI_EVENT_BATTERY_INSERT },
 	{ 0x30, SONYPI_EVENT_BATTERY_REMOVE },
 	{ 0, 0 }
 };
 static struct sonypi_eventtypes {
 	int			model;
 	u8			data;
 	unsigned long		mask;
 	struct sonypi_event *	events;
 } sonypi_eventtypes[] = {
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0, 0xffffffff, sonypi_releaseev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x70, SONYPI_MEYE_MASK, sonypi_meyeev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x30, SONYPI_LID_MASK, sonypi_lidev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x60, SONYPI_CAPTURE_MASK, sonypi_captureev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x10, SONYPI_JOGGER_MASK, sonypi_joggerev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x20, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x30, SONYPI_BLUETOOTH_MASK, sonypi_blueev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x40, SONYPI_PKEY_MASK, sonypi_pkeyev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x30, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
 	{ SONYPI_DEVICE_MODEL_TYPE1, 0x40, SONYPI_BATTERY_MASK, sonypi_batteryev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0, 0xffffffff, sonypi_releaseev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x38, SONYPI_LID_MASK, sonypi_lidev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x11, SONYPI_JOGGER_MASK, sonypi_joggerev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x61, SONYPI_CAPTURE_MASK, sonypi_captureev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x21, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x31, SONYPI_BLUETOOTH_MASK, sonypi_blueev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x08, SONYPI_PKEY_MASK, sonypi_pkeyev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x11, SONYPI_BACK_MASK, sonypi_backev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x21, SONYPI_HELP_MASK, sonypi_helpev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x21, SONYPI_ZOOM_MASK, sonypi_zoomev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x20, SONYPI_THUMBPHRASE_MASK, sonypi_thumbphraseev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x31, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
 	{ SONYPI_DEVICE_MODEL_TYPE2, 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
 	{ SONYPI_DEVICE_MODEL_TYPE3, 0, 0xffffffff, sonypi_releaseev },
 	{ SONYPI_DEVICE_MODEL_TYPE3, 0x21, SONYPI_FNKEY_MASK, sonypi_fnkeyev },
 	{ SONYPI_DEVICE_MODEL_TYPE3, 0x31, SONYPI_WIRELESS_MASK, sonypi_wlessev },
 	{ SONYPI_DEVICE_MODEL_TYPE3, 0x31, SONYPI_MEMORYSTICK_MASK, sonypi_memorystickev },
 	{ SONYPI_DEVICE_MODEL_TYPE3, 0x41, SONYPI_BATTERY_MASK, sonypi_batteryev },
 	{ SONYPI_DEVICE_MODEL_TYPE3, 0x31, SONYPI_PKEY_MASK, sonypi_pkeyev },
 	{ 0 }
 };
 #define SONYPI_BUF_SIZE	128
 /* Correspondance table between sonypi events and input layer events */
 static struct {
 	int sonypiev;
 	int inputev;
 } sonypi_inputkeys[] = {
 	{ SONYPI_EVENT_CAPTURE_PRESSED,	 	KEY_CAMERA },
 	{ SONYPI_EVENT_FNKEY_ONLY, 		KEY_FN },
 	{ SONYPI_EVENT_FNKEY_ESC, 		KEY_FN_ESC },
 	{ SONYPI_EVENT_FNKEY_F1, 		KEY_FN_F1 },
 	{ SONYPI_EVENT_FNKEY_F2, 		KEY_FN_F2 },
 	{ SONYPI_EVENT_FNKEY_F3, 		KEY_FN_F3 },
 	{ SONYPI_EVENT_FNKEY_F4, 		KEY_FN_F4 },
 	{ SONYPI_EVENT_FNKEY_F5, 		KEY_FN_F5 },
 	{ SONYPI_EVENT_FNKEY_F6, 		KEY_FN_F6 },
 	{ SONYPI_EVENT_FNKEY_F7, 		KEY_FN_F7 },
 	{ SONYPI_EVENT_FNKEY_F8, 		KEY_FN_F8 },
 	{ SONYPI_EVENT_FNKEY_F9,		KEY_FN_F9 },
 	{ SONYPI_EVENT_FNKEY_F10,		KEY_FN_F10 },
 	{ SONYPI_EVENT_FNKEY_F11, 		KEY_FN_F11 },
 	{ SONYPI_EVENT_FNKEY_F12,		KEY_FN_F12 },
 	{ SONYPI_EVENT_FNKEY_1, 		KEY_FN_1 },
 	{ SONYPI_EVENT_FNKEY_2, 		KEY_FN_2 },
 	{ SONYPI_EVENT_FNKEY_D,			KEY_FN_D },
 	{ SONYPI_EVENT_FNKEY_E,			KEY_FN_E },
 	{ SONYPI_EVENT_FNKEY_F,			KEY_FN_F },
 	{ SONYPI_EVENT_FNKEY_S,			KEY_FN_S },
 	{ SONYPI_EVENT_FNKEY_B,			KEY_FN_B },
 	{ SONYPI_EVENT_BLUETOOTH_PRESSED, 	KEY_BLUE },
 	{ SONYPI_EVENT_BLUETOOTH_ON, 		KEY_BLUE },
 	{ SONYPI_EVENT_PKEY_P1, 		KEY_PROG1 },
 	{ SONYPI_EVENT_PKEY_P2, 		KEY_PROG2 },
 	{ SONYPI_EVENT_PKEY_P3, 		KEY_PROG3 },
 	{ SONYPI_EVENT_BACK_PRESSED, 		KEY_BACK },
 	{ SONYPI_EVENT_HELP_PRESSED, 		KEY_HELP },
 	{ SONYPI_EVENT_ZOOM_PRESSED, 		KEY_ZOOM },
 	{ SONYPI_EVENT_THUMBPHRASE_PRESSED, 	BTN_THUMB },
 	{ 0, 0 },
 };
 struct sonypi_keypress {
 	struct input_dev *dev;
 	int key;
 };
 static struct sonypi_device {
 	struct pci_dev *dev;
 	u16 irq;
 	u16 bits;
 	u16 ioport1;
 	u16 ioport2;
 	u16 region_size;
 	u16 evtype_offset;
 	int camera_power;
 	int bluetooth_power;
 	struct mutex lock;
 	struct kfifo *fifo;
 	spinlock_t fifo_lock;
 	wait_queue_head_t fifo_proc_list;
 	struct fasync_struct *fifo_async;
 	int open_count;
 	int model;
 	struct input_dev *input_jog_dev;
 	struct input_dev *input_key_dev;
 	struct work_struct input_work;
 	struct kfifo *input_fifo;
 	spinlock_t input_fifo_lock;
 } sonypi_device;
 #define ITERATIONS_LONG		10000
 #define ITERATIONS_SHORT	10
 #define wait_on_command(quiet, command, iterations) { \
 	unsigned int n = iterations; \
 	while (--n && (command)) \
 		udelay(1); \
 	if (!n && (verbose || !quiet)) \
 		printk(KERN_WARNING "sonypi command failed at %s : %s (line %d)\n", __FILE__, __func__, __LINE__); \
 }
 #ifdef CONFIG_ACPI
 #define SONYPI_ACPI_ACTIVE (!acpi_disabled)
 #else
 #define SONYPI_ACPI_ACTIVE 0
 #endif				/* CONFIG_ACPI */
 #ifdef CONFIG_ACPI
 static struct acpi_device *sonypi_acpi_device;
 static int acpi_driver_registered;
 #endif
 static int sonypi_ec_write(u8 addr, u8 value)
 {
 #ifdef CONFIG_ACPI
 	if (SONYPI_ACPI_ACTIVE)
 		return ec_write(addr, value);
 #endif
 	wait_on_command(1, inb_p(SONYPI_CST_IOPORT) & 3, ITERATIONS_LONG);
 	outb_p(0x81, SONYPI_CST_IOPORT);
 	wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2, ITERATIONS_LONG);
 	outb_p(addr, SONYPI_DATA_IOPORT);
 	wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2, ITERATIONS_LONG);
 	outb_p(value, SONYPI_DATA_IOPORT);
 	wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2, ITERATIONS_LONG);
 	return 0;
 }
 static int sonypi_ec_read(u8 addr, u8 *value)
 {
 #ifdef CONFIG_ACPI
 	if (SONYPI_ACPI_ACTIVE)
 		return ec_read(addr, value);
 #endif
 	wait_on_command(1, inb_p(SONYPI_CST_IOPORT) & 3, ITERATIONS_LONG);
 	outb_p(0x80, SONYPI_CST_IOPORT);
 	wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2, ITERATIONS_LONG);
 	outb_p(addr, SONYPI_DATA_IOPORT);
 	wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2, ITERATIONS_LONG);
 	*value = inb_p(SONYPI_DATA_IOPORT);
 	return 0;
 }
 static int ec_read16(u8 addr, u16 *value)
 {
 	u8 val_lb, val_hb;
 	if (sonypi_ec_read(addr, &val_lb))
 		return -1;
 	if (sonypi_ec_read(addr + 1, &val_hb))
 		return -1;
 	*value = val_lb | (val_hb << 8);
 	return 0;
 }
 /* Initializes the device - this comes from the AML code in the ACPI bios */
 static void sonypi_type1_srs(void)
 {
 	u32 v;
 	pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
 	v = (v & 0xFFFF0000) | ((u32) sonypi_device.ioport1);
 	pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
 	pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
 	v = (v & 0xFFF0FFFF) |
 	    (((u32) sonypi_device.ioport1 ^ sonypi_device.ioport2) << 16);
 	pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
 	v = inl(SONYPI_IRQ_PORT);
 	v &= ~(((u32) 0x3) << SONYPI_IRQ_SHIFT);
 	v |= (((u32) sonypi_device.bits) << SONYPI_IRQ_SHIFT);
 	outl(v, SONYPI_IRQ_PORT);
 	pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
 	v = (v & 0xFF1FFFFF) | 0x00C00000;
 	pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
 }
 static void sonypi_type2_srs(void)
 {
 	if (sonypi_ec_write(SONYPI_SHIB, (sonypi_device.ioport1 & 0xFF00) >> 8))
 		printk(KERN_WARNING "ec_write failed\n");
 	if (sonypi_ec_write(SONYPI_SLOB, sonypi_device.ioport1 & 0x00FF))
 		printk(KERN_WARNING "ec_write failed\n");
 	if (sonypi_ec_write(SONYPI_SIRQ, sonypi_device.bits))
 		printk(KERN_WARNING "ec_write failed\n");
 	udelay(10);
 }
 static void sonypi_type3_srs(void)
 {
 	u16 v16;
 	u8  v8;
 	/* This model type uses the same initialiazation of
 	 * the embedded controller as the type2 models. */
 	sonypi_type2_srs();
 	/* Initialization of PCI config space of the LPC interface bridge. */
 	v16 = (sonypi_device.ioport1 & 0xFFF0) | 0x01;
 	pci_write_config_word(sonypi_device.dev, SONYPI_TYPE3_GID2, v16);
 	pci_read_config_byte(sonypi_device.dev, SONYPI_TYPE3_MISC, &v8);
 	v8 = (v8 & 0xCF) | 0x10;
 	pci_write_config_byte(sonypi_device.dev, SONYPI_TYPE3_MISC, v8);
 }
 /* Disables the device - this comes from the AML code in the ACPI bios */
 static void sonypi_type1_dis(void)
 {
 	u32 v;
 	pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
 	v = v & 0xFF3FFFFF;
 	pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
 	v = inl(SONYPI_IRQ_PORT);
 	v |= (0x3 << SONYPI_IRQ_SHIFT);
 	outl(v, SONYPI_IRQ_PORT);
 }
 static void sonypi_type2_dis(void)
 {
 	if (sonypi_ec_write(SONYPI_SHIB, 0))
 		printk(KERN_WARNING "ec_write failed\n");
 	if (sonypi_ec_write(SONYPI_SLOB, 0))
 		printk(KERN_WARNING "ec_write failed\n");
 	if (sonypi_ec_write(SONYPI_SIRQ, 0))
 		printk(KERN_WARNING "ec_write failed\n");
 }
 static void sonypi_type3_dis(void)
 {
 	sonypi_type2_dis();
 	udelay(10);
 	pci_write_config_word(sonypi_device.dev, SONYPI_TYPE3_GID2, 0);
 }
 static u8 sonypi_call1(u8 dev)
 {
 	u8 v1, v2;
 	wait_on_command(0, inb_p(sonypi_device.ioport2) & 2, ITERATIONS_LONG);
 	outb(dev, sonypi_device.ioport2);
 	v1 = inb_p(sonypi_device.ioport2);
 	v2 = inb_p(sonypi_device.ioport1);
 	return v2;
 }
 static u8 sonypi_call2(u8 dev, u8 fn)
 {
 	u8 v1;
 	wait_on_command(0, inb_p(sonypi_device.ioport2) & 2, ITERATIONS_LONG);
 	outb(dev, sonypi_device.ioport2);
 	wait_on_command(0, inb_p(sonypi_device.ioport2) & 2, ITERATIONS_LONG);
 	outb(fn, sonypi_device.ioport1);
 	v1 = inb_p(sonypi_device.ioport1);
 	return v1;
 }
 static u8 sonypi_call3(u8 dev, u8 fn, u8 v)
 {
 	u8 v1;
 	wait_on_command(0, inb_p(sonypi_device.ioport2) & 2, ITERATIONS_LONG);
 	outb(dev, sonypi_device.ioport2);
 	wait_on_command(0, inb_p(sonypi_device.ioport2) & 2, ITERATIONS_LONG);
 	outb(fn, sonypi_device.ioport1);
 	wait_on_command(0, inb_p(sonypi_device.ioport2) & 2, ITERATIONS_LONG);
 	outb(v, sonypi_device.ioport1);
 	v1 = inb_p(sonypi_device.ioport1);
 	return v1;
 }
 #if 0
 /* Get brightness, hue etc. Unreliable... */
 static u8 sonypi_read(u8 fn)
 {
 	u8 v1, v2;
 	int n = 100;
 	while (n--) {
 		v1 = sonypi_call2(0x8f, fn);
 		v2 = sonypi_call2(0x8f, fn);
 		if (v1 == v2 && v1 != 0xff)
 			return v1;
 	}
 	return 0xff;
 }
 #endif
 /* Set brightness, hue etc */
 static void sonypi_set(u8 fn, u8 v)
 {
 	wait_on_command(0, sonypi_call3(0x90, fn, v), ITERATIONS_SHORT);
 }
 /* Tests if the camera is ready */
 static int sonypi_camera_ready(void)
 {
 	u8 v;
 	v = sonypi_call2(0x8f, SONYPI_CAMERA_STATUS);
 	return (v != 0xff && (v & SONYPI_CAMERA_STATUS_READY));
 }
 /* Turns the camera off */
 static void sonypi_camera_off(void)
 {
 	sonypi_set(SONYPI_CAMERA_PICTURE, SONYPI_CAMERA_MUTE_MASK);
 	if (!sonypi_device.camera_power)
 		return;
 	sonypi_call2(0x91, 0);
 	sonypi_device.camera_power = 0;
 }
 /* Turns the camera on */
 static void sonypi_camera_on(void)
 {
 	int i, j;
 	if (sonypi_device.camera_power)
 		return;
 	for (j = 5; j > 0; j--) {
 		while (sonypi_call2(0x91, 0x1))
 			msleep(10);
 		sonypi_call1(0x93);
 		for (i = 400; i > 0; i--) {
 			if (sonypi_camera_ready())
 				break;
 			msleep(10);
 		}
 		if (i)
 			break;
 	}
 	if (j == 0) {
 		printk(KERN_WARNING "sonypi: failed to power on camera\n");
 		return;
 	}
 	sonypi_set(0x10, 0x5a);
 	sonypi_device.camera_power = 1;
 }
 /* sets the bluetooth subsystem power state */
 static void sonypi_setbluetoothpower(u8 state)
 {
 	state = !!state;
 	if (sonypi_device.bluetooth_power == state)
 		return;
 	sonypi_call2(0x96, state);
 	sonypi_call1(0x82);
 	sonypi_device.bluetooth_power = state;
 }
 static void input_keyrelease(struct work_struct *work)
 {
 	struct sonypi_keypress kp;
 	while (kfifo_get(sonypi_device.input_fifo, (unsigned char *)&kp,
 			 sizeof(kp)) == sizeof(kp)) {
 		msleep(10);
 		input_report_key(kp.dev, kp.key, 0);
 		input_sync(kp.dev);
 	}
 }
 static void sonypi_report_input_event(u8 event)
 {
 	struct input_dev *jog_dev = sonypi_device.input_jog_dev;
 	struct input_dev *key_dev = sonypi_device.input_key_dev;
 	struct sonypi_keypress kp = { NULL };
 	int i;
 	switch (event) {
 	case SONYPI_EVENT_JOGDIAL_UP:
 	case SONYPI_EVENT_JOGDIAL_UP_PRESSED:
 		input_report_rel(jog_dev, REL_WHEEL, 1);
 		input_sync(jog_dev);
 		break;
 	case SONYPI_EVENT_JOGDIAL_DOWN:
 	case SONYPI_EVENT_JOGDIAL_DOWN_PRESSED:
 		input_report_rel(jog_dev, REL_WHEEL, -1);
 		input_sync(jog_dev);
 		break;
 	case SONYPI_EVENT_JOGDIAL_PRESSED:
 		kp.key = BTN_MIDDLE;
 		kp.dev = jog_dev;
 		break;
 	case SONYPI_EVENT_FNKEY_RELEASED:
 		/* Nothing, not all VAIOs generate this event */
 		break;
 	default:
 		for (i = 0; sonypi_inputkeys[i].sonypiev; i++)
 			if (event == sonypi_inputkeys[i].sonypiev) {
 				kp.dev = key_dev;
 				kp.key = sonypi_inputkeys[i].inputev;
 				break;
 			}
 		break;
 	}
 	if (kp.dev) {
 		input_report_key(kp.dev, kp.key, 1);
 		input_sync(kp.dev);
 		kfifo_put(sonypi_device.input_fifo,
 			  (unsigned char *)&kp, sizeof(kp));
 		schedule_work(&sonypi_device.input_work);
 	}
 }
 /* Interrupt handler: some event is available */
 static irqreturn_t sonypi_irq(int irq, void *dev_id)
 {
 	u8 v1, v2, event = 0;
 	int i, j;
 	v1 = inb_p(sonypi_device.ioport1);
 	v2 = inb_p(sonypi_device.ioport1 + sonypi_device.evtype_offset);
 	for (i = 0; sonypi_eventtypes[i].model; i++) {
 		if (sonypi_device.model != sonypi_eventtypes[i].model)
 			continue;
 		if ((v2 & sonypi_eventtypes[i].data) !=
 		    sonypi_eventtypes[i].data)
 			continue;
 		if (!(mask & sonypi_eventtypes[i].mask))
 			continue;
 		for (j = 0; sonypi_eventtypes[i].events[j].event; j++) {
 			if (v1 == sonypi_eventtypes[i].events[j].data) {
 				event = sonypi_eventtypes[i].events[j].event;
 				goto found;
 			}
 		}
 	}
 	if (verbose)
 		printk(KERN_WARNING
 		       "sonypi: unknown event port1=0x%02x,port2=0x%02x\n",
 		       v1, v2);
 	/* We need to return IRQ_HANDLED here because there *are*
 	 * events belonging to the sonypi device we don't know about,
 	 * but we still don't want those to pollute the logs... */
 	return IRQ_HANDLED;
 found:
 	if (verbose > 1)
 		printk(KERN_INFO
 		       "sonypi: event port1=0x%02x,port2=0x%02x\n", v1, v2);
 	if (useinput)
 		sonypi_report_input_event(event);
 #ifdef CONFIG_ACPI
 	if (sonypi_acpi_device)
 		acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event);
 #endif
 	kfifo_put(sonypi_device.fifo, (unsigned char *)&event, sizeof(event));
 	kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
 	wake_up_interruptible(&sonypi_device.fifo_proc_list);
 	return IRQ_HANDLED;
 }
 static int sonypi_misc_fasync(int fd, struct file *filp, int on)
 {
 	return fasync_helper(fd, filp, on, &sonypi_device.fifo_async);
 }
 static int sonypi_misc_release(struct inode *inode, struct file *file)
 {
 	mutex_lock(&sonypi_device.lock);
 	sonypi_device.open_count--;
 	mutex_unlock(&sonypi_device.lock);
 	return 0;
 }
 static int sonypi_misc_open(struct inode *inode, struct file *file)
 {
 	lock_kernel();
 	mutex_lock(&sonypi_device.lock);
 	/* Flush input queue on first open */
 	if (!sonypi_device.open_count)
 		kfifo_reset(sonypi_device.fifo);
 	sonypi_device.open_count++;
 	mutex_unlock(&sonypi_device.lock);
 	unlock_kernel();
 	return 0;
 }
 static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
 				size_t count, loff_t *pos)
 {
 	ssize_t ret;
 	unsigned char c;
 	if ((kfifo_len(sonypi_device.fifo) == 0) &&
 	    (file->f_flags & O_NONBLOCK))
 		return -EAGAIN;
 	ret = wait_event_interruptible(sonypi_device.fifo_proc_list,
 				       kfifo_len(sonypi_device.fifo) != 0);
 	if (ret)
 		return ret;
 	while (ret < count &&
 	       (kfifo_get(sonypi_device.fifo, &c, sizeof(c)) == sizeof(c))) {
 		if (put_user(c, buf++))
 			return -EFAULT;
 		ret++;
 	}
 	if (ret > 0) {
 		struct inode *inode = file->f_path.dentry->d_inode;
 		inode->i_atime = current_fs_time(inode->i_sb);
 	}
 	return ret;
 }
 static unsigned int sonypi_misc_poll(struct file *file, poll_table *wait)
 {
 	poll_wait(file, &sonypi_device.fifo_proc_list, wait);
 	if (kfifo_len(sonypi_device.fifo))
 		return POLLIN | POLLRDNORM;
 	return 0;
 }
 static int sonypi_misc_ioctl(struct inode *ip, struct file *fp,
 			     unsigned int cmd, unsigned long arg)
 {
 	int ret = 0;
 	void __user *argp = (void __user *)arg;
 	u8 val8;
 	u16 val16;
 	mutex_lock(&sonypi_device.lock);
 	switch (cmd) {
 	case SONYPI_IOCGBRT:
 		if (sonypi_ec_read(SONYPI_LCD_LIGHT, &val8)) {
 			ret = -EIO;
 			break;
 		}
 		if (copy_to_user(argp, &val8, sizeof(val8)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCSBRT:
 		if (copy_from_user(&val8, argp, sizeof(val8))) {
 			ret = -EFAULT;
 			break;
 		}
 		if (sonypi_ec_write(SONYPI_LCD_LIGHT, val8))
 			ret = -EIO;
 		break;
 	case SONYPI_IOCGBAT1CAP:
 		if (ec_read16(SONYPI_BAT1_FULL, &val16)) {
 			ret = -EIO;
 			break;
 		}
 		if (copy_to_user(argp, &val16, sizeof(val16)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCGBAT1REM:
 		if (ec_read16(SONYPI_BAT1_LEFT, &val16)) {
 			ret = -EIO;
 			break;
 		}
 		if (copy_to_user(argp, &val16, sizeof(val16)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCGBAT2CAP:
 		if (ec_read16(SONYPI_BAT2_FULL, &val16)) {
 			ret = -EIO;
 			break;
 		}
 		if (copy_to_user(argp, &val16, sizeof(val16)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCGBAT2REM:
 		if (ec_read16(SONYPI_BAT2_LEFT, &val16)) {
 			ret = -EIO;
 			break;
 		}
 		if (copy_to_user(argp, &val16, sizeof(val16)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCGBATFLAGS:
 		if (sonypi_ec_read(SONYPI_BAT_FLAGS, &val8)) {
 			ret = -EIO;
 			break;
 		}
 		val8 &= 0x07;
 		if (copy_to_user(argp, &val8, sizeof(val8)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCGBLUE:
 		val8 = sonypi_device.bluetooth_power;
 		if (copy_to_user(argp, &val8, sizeof(val8)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCSBLUE:
 		if (copy_from_user(&val8, argp, sizeof(val8))) {
 			ret = -EFAULT;
 			break;
 		}
 		sonypi_setbluetoothpower(val8);
 		break;
 	/* FAN Controls */
 	case SONYPI_IOCGFAN:
 		if (sonypi_ec_read(SONYPI_FAN0_STATUS, &val8)) {
 			ret = -EIO;
 			break;
 		}
 		if (copy_to_user(argp, &val8, sizeof(val8)))
 			ret = -EFAULT;
 		break;
 	case SONYPI_IOCSFAN:
 		if (copy_from_user(&val8, argp, sizeof(val8))) {
 			ret = -EFAULT;
 			break;
 		}
 		if (sonypi_ec_write(SONYPI_FAN0_STATUS, val8))
 			ret = -EIO;
 		break;
 	/* GET Temperature (useful under APM) */
 	case SONYPI_IOCGTEMP:
 		if (sonypi_ec_read(SONYPI_TEMP_STATUS, &val8)) {
 			ret = -EIO;
 			break;
 		}
 		if (copy_to_user(argp, &val8, sizeof(val8)))
 			ret = -EFAULT;
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	mutex_unlock(&sonypi_device.lock);
 	return ret;
 }
 static const struct file_operations sonypi_misc_fops = {
 	.owner		= THIS_MODULE,
 	.read		= sonypi_misc_read,
 	.poll		= sonypi_misc_poll,
 	.open		= sonypi_misc_open,
 	.release	= sonypi_misc_release,
 	.fasync		= sonypi_misc_fasync,
 	.ioctl		= sonypi_misc_ioctl,
 };
 static struct miscdevice sonypi_misc_device = {
 	.minor		= MISC_DYNAMIC_MINOR,
 	.name		= "sonypi",
 	.fops		= &sonypi_misc_fops,
 };
 static void sonypi_enable(unsigned int camera_on)
 {
 	switch (sonypi_device.model) {
 	case SONYPI_DEVICE_MODEL_TYPE1:
 		sonypi_type1_srs();
 		break;
 	case SONYPI_DEVICE_MODEL_TYPE2:
 		sonypi_type2_srs();
 		break;
 	case SONYPI_DEVICE_MODEL_TYPE3:
 		sonypi_type3_srs();
 		break;
 	}
 	sonypi_call1(0x82);
 	sonypi_call2(0x81, 0xff);
 	sonypi_call1(compat ? 0x92 : 0x82);
 	/* Enable ACPI mode to get Fn key events */
 	if (!SONYPI_ACPI_ACTIVE && fnkeyinit)
 		outb(0xf0, 0xb2);
 	if (camera && camera_on)
 		sonypi_camera_on();
 }
 static int sonypi_disable(void)
 {
 	sonypi_call2(0x81, 0);	/* make sure we don't get any more events */
 	if (camera)
 		sonypi_camera_off();
 	/* disable ACPI mode */
 	if (!SONYPI_ACPI_ACTIVE && fnkeyinit)
 		outb(0xf1, 0xb2);
 	switch (sonypi_device.model) {
 	case SONYPI_DEVICE_MODEL_TYPE1:
 		sonypi_type1_dis();
 		break;
 	case SONYPI_DEVICE_MODEL_TYPE2:
 		sonypi_type2_dis();
 		break;
 	case SONYPI_DEVICE_MODEL_TYPE3:
 		sonypi_type3_dis();
 		break;
 	}
 	return 0;
 }
 #ifdef CONFIG_ACPI
 static int sonypi_acpi_add(struct acpi_device *device)
 {
 	sonypi_acpi_device = device;
 	strcpy(acpi_device_name(device), "Sony laptop hotkeys");
 	strcpy(acpi_device_class(device), "sony/hotkey");
 	return 0;
 }
 static int sonypi_acpi_remove(struct acpi_device *device, int type)
 {
 	sonypi_acpi_device = NULL;
 	return 0;
 }
 static const struct acpi_device_id sonypi_device_ids[] = {
 	{"SNY6001", 0},
 	{"", 0},
 };
 static struct acpi_driver sonypi_acpi_driver = {
 	.name           = "sonypi",
 	.class          = "hkey",
 	.ids            = sonypi_device_ids,
 	.ops            = {
 		           .add = sonypi_acpi_add,
 			   .remove = sonypi_acpi_remove,
 	},
 };
 #endif
 static int __devinit sonypi_create_input_devices(struct platform_device *pdev)
 {
 	struct input_dev *jog_dev;
 	struct input_dev *key_dev;
 	int i;
 	int error;
 	sonypi_device.input_jog_dev = jog_dev = input_allocate_device();
 	if (!jog_dev)
 		return -ENOMEM;
 	jog_dev->name = "Sony Vaio Jogdial";
 	jog_dev->id.bustype = BUS_ISA;
 	jog_dev->id.vendor = PCI_VENDOR_ID_SONY;
 	jog_dev->dev.parent = &pdev->dev;
 	jog_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
 	jog_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_MIDDLE);
 	jog_dev->relbit[0] = BIT_MASK(REL_WHEEL);
 	sonypi_device.input_key_dev = key_dev = input_allocate_device();
 	if (!key_dev) {
 		error = -ENOMEM;
 		goto err_free_jogdev;
 	}
 	key_dev->name = "Sony Vaio Keys";
 	key_dev->id.bustype = BUS_ISA;
 	key_dev->id.vendor = PCI_VENDOR_ID_SONY;
 	key_dev->dev.parent = &pdev->dev;
 	/* Initialize the Input Drivers: special keys */
 	key_dev->evbit[0] = BIT_MASK(EV_KEY);
 	for (i = 0; sonypi_inputkeys[i].sonypiev; i++)
 		if (sonypi_inputkeys[i].inputev)
 			set_bit(sonypi_inputkeys[i].inputev, key_dev->keybit);
 	error = input_register_device(jog_dev);
 	if (error)
 		goto err_free_keydev;
 	error = input_register_device(key_dev);
 	if (error)
 		goto err_unregister_jogdev;
 	return 0;
  err_unregister_jogdev:
 	input_unregister_device(jog_dev);
 	/* Set to NULL so we don't free it again below */
 	jog_dev = NULL;
  err_free_keydev:
 	input_free_device(key_dev);
 	sonypi_device.input_key_dev = NULL;
  err_free_jogdev:
 	input_free_device(jog_dev);
 	sonypi_device.input_jog_dev = NULL;
 	return error;
 }
 static int __devinit sonypi_setup_ioports(struct sonypi_device *dev,
 				const struct sonypi_ioport_list *ioport_list)
 {
 	/* try to detect if sony-laptop is being used and thus
 	 * has already requested one of the known ioports.
 	 * As in the deprecated check_region this is racy has we have
 	 * multiple ioports available and one of them can be requested
 	 * between this check and the subsequent request. Anyway, as an
 	 * attempt to be some more user-friendly as we currently are,
 	 * this is enough.
 	 */
 	const struct sonypi_ioport_list *check = ioport_list;
 	while (check_ioport && check->port1) {
 		if (!request_region(check->port1,
 				   sonypi_device.region_size,
 				   "Sony Programable I/O Device Check")) {
 			printk(KERN_ERR "sonypi: ioport 0x%.4x busy, using sony-laptop? "
 					"if not use check_ioport=0\n",
 					check->port1);
 			return -EBUSY;
 		}
 		release_region(check->port1, sonypi_device.region_size);
 		check++;
 	}
 	while (ioport_list->port1) {
 		if (request_region(ioport_list->port1,
 				   sonypi_device.region_size,
 				   "Sony Programable I/O Device")) {
 			dev->ioport1 = ioport_list->port1;
 			dev->ioport2 = ioport_list->port2;
 			return 0;
 		}
 		ioport_list++;
 	}
 	return -EBUSY;
 }
 static int __devinit sonypi_setup_irq(struct sonypi_device *dev,
 				      const struct sonypi_irq_list *irq_list)
 {
 	while (irq_list->irq) {
 		if (!request_irq(irq_list->irq, sonypi_irq,
 				 IRQF_SHARED, "sonypi", sonypi_irq)) {
 			dev->irq = irq_list->irq;
 			dev->bits = irq_list->bits;
 			return 0;
 		}
 		irq_list++;
 	}
 	return -EBUSY;
 }
 static void __devinit sonypi_display_info(void)
 {
 	printk(KERN_INFO "sonypi: detected type%d model, "
 	       "verbose = %d, fnkeyinit = %s, camera = %s, "
 	       "compat = %s, mask = 0x%08lx, useinput = %s, acpi = %s\n",
 	       sonypi_device.model,
 	       verbose,
 	       fnkeyinit ? "on" : "off",
 	       camera ? "on" : "off",
 	       compat ? "on" : "off",
 	       mask,
 	       useinput ? "on" : "off",
 	       SONYPI_ACPI_ACTIVE ? "on" : "off");
 	printk(KERN_INFO "sonypi: enabled at irq=%d, port1=0x%x, port2=0x%x\n",
 	       sonypi_device.irq,
 	       sonypi_device.ioport1, sonypi_device.ioport2);
 	if (minor == -1)
 		printk(KERN_INFO "sonypi: device allocated minor is %d\n",
 		       sonypi_misc_device.minor);
 }
 static int __devinit sonypi_probe(struct platform_device *dev)
 {
 	const struct sonypi_ioport_list *ioport_list;
 	const struct sonypi_irq_list *irq_list;
 	struct pci_dev *pcidev;
 	int error;
 	printk(KERN_WARNING "sonypi: please try the sony-laptop module instead "
 			"and report failures, see also "
 			"http://www.linux.it/~malattia/wiki/index.php/Sony_drivers\n");
 	spin_lock_init(&sonypi_device.fifo_lock);
 	sonypi_device.fifo = kfifo_alloc(SONYPI_BUF_SIZE, GFP_KERNEL,
 					 &sonypi_device.fifo_lock);
 	if (IS_ERR(sonypi_device.fifo)) {
 		printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
 		return PTR_ERR(sonypi_device.fifo);
 	}
 	init_waitqueue_head(&sonypi_device.fifo_proc_list);
 	mutex_init(&sonypi_device.lock);
 	sonypi_device.bluetooth_power = -1;
 	if ((pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
 				     PCI_DEVICE_ID_INTEL_82371AB_3, NULL)))
 		sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE1;
 	else if ((pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
 					  PCI_DEVICE_ID_INTEL_ICH6_1, NULL)))
 		sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE3;
 	else if ((pcidev = pci_get_device(PCI_VENDOR_ID_INTEL,
 					  PCI_DEVICE_ID_INTEL_ICH7_1, NULL)))
 		sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE3;
 	else
 		sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE2;
 	if (pcidev && pci_enable_device(pcidev)) {
 		printk(KERN_ERR "sonypi: pci_enable_device failed\n");
 		error = -EIO;
 		goto err_put_pcidev;
 	}
 	sonypi_device.dev = pcidev;
 	if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE1) {
 		ioport_list = sonypi_type1_ioport_list;
 		sonypi_device.region_size = SONYPI_TYPE1_REGION_SIZE;
 		sonypi_device.evtype_offset = SONYPI_TYPE1_EVTYPE_OFFSET;
 		irq_list = sonypi_type1_irq_list;
 	} else if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2) {
 		ioport_list = sonypi_type2_ioport_list;
 		sonypi_device.region_size = SONYPI_TYPE2_REGION_SIZE;
 		sonypi_device.evtype_offset = SONYPI_TYPE2_EVTYPE_OFFSET;
 		irq_list = sonypi_type2_irq_list;
 	} else {
 		ioport_list = sonypi_type3_ioport_list;
 		sonypi_device.region_size = SONYPI_TYPE3_REGION_SIZE;
 		sonypi_device.evtype_offset = SONYPI_TYPE3_EVTYPE_OFFSET;
 		irq_list = sonypi_type3_irq_list;
 	}
 	error = sonypi_setup_ioports(&sonypi_device, ioport_list);
 	if (error) {
 		printk(KERN_ERR "sonypi: failed to request ioports\n");
 		goto err_disable_pcidev;
 	}
 	error = sonypi_setup_irq(&sonypi_device, irq_list);
 	if (error) {
 		printk(KERN_ERR "sonypi: request_irq failed\n");
 		goto err_free_ioports;
 	}
 	if (minor != -1)
 		sonypi_misc_device.minor = minor;
 	error = misc_register(&sonypi_misc_device);
 	if (error) {
 		printk(KERN_ERR "sonypi: misc_register failed\n");
 		goto err_free_irq;
 	}
 	sonypi_display_info();
 	if (useinput) {
 		error = sonypi_create_input_devices(dev);
 		if (error) {
 			printk(KERN_ERR
 				"sonypi: failed to create input devices\n");
 			goto err_miscdev_unregister;
 		}
 		spin_lock_init(&sonypi_device.input_fifo_lock);
 		sonypi_device.input_fifo =
 			kfifo_alloc(SONYPI_BUF_SIZE, GFP_KERNEL,
 				    &sonypi_device.input_fifo_lock);
 		if (IS_ERR(sonypi_device.input_fifo)) {
 			printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
 			error = PTR_ERR(sonypi_device.input_fifo);
 			goto err_inpdev_unregister;
 		}
 		INIT_WORK(&sonypi_device.input_work, input_keyrelease);
 	}
 	sonypi_enable(0);
 	return 0;
  err_inpdev_unregister:
 	input_unregister_device(sonypi_device.input_key_dev);
 	input_unregister_device(sonypi_device.input_jog_dev);
  err_miscdev_unregister:
 	misc_deregister(&sonypi_misc_device);
  err_free_irq:
 	free_irq(sonypi_device.irq, sonypi_irq);
  err_free_ioports:
 	release_region(sonypi_device.ioport1, sonypi_device.region_size);
  err_disable_pcidev:
 	if (pcidev)
 		pci_disable_device(pcidev);
  err_put_pcidev:
 	pci_dev_put(pcidev);
 	kfifo_free(sonypi_device.fifo);
 	return error;
 }
 static int __devexit sonypi_remove(struct platform_device *dev)
 {
 	sonypi_disable();
 	synchronize_irq(sonypi_device.irq);
 	flush_scheduled_work();
 	if (useinput) {
 		input_unregister_device(sonypi_device.input_key_dev);
 		input_unregister_device(sonypi_device.input_jog_dev);
 		kfifo_free(sonypi_device.input_fifo);
 	}
 	misc_deregister(&sonypi_misc_device);
 	free_irq(sonypi_device.irq, sonypi_irq);
 	release_region(sonypi_device.ioport1, sonypi_device.region_size);
 	if (sonypi_device.dev) {
 		pci_disable_device(sonypi_device.dev);
 		pci_dev_put(sonypi_device.dev);
 	}
 	kfifo_free(sonypi_device.fifo);
 	return 0;
 }
 #ifdef CONFIG_PM
 static int old_camera_power;
 static int sonypi_suspend(struct platform_device *dev, pm_message_t state)
 {
 	old_camera_power = sonypi_device.camera_power;
 	sonypi_disable();
 	return 0;
 }
 static int sonypi_resume(struct platform_device *dev)
 {
 	sonypi_enable(old_camera_power);
 	return 0;
 }
 #else
 #define sonypi_suspend	NULL
 #define sonypi_resume	NULL
 #endif
 static void sonypi_shutdown(struct platform_device *dev)
 {
 	sonypi_disable();
 }
 static struct platform_driver sonypi_driver = {
 	.driver		= {
 		.name	= "sonypi",
 		.owner	= THIS_MODULE,
 	},
 	.probe		= sonypi_probe,
 	.remove		= __devexit_p(sonypi_remove),
 	.shutdown	= sonypi_shutdown,
 	.suspend	= sonypi_suspend,
 	.resume		= sonypi_resume,
 };
 static struct platform_device *sonypi_platform_device;
 static struct dmi_system_id __initdata sonypi_dmi_table[] = {
 	{
 		.ident = "Sony Vaio",
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "PCG-"),
 		},
 	},
 	{
 		.ident = "Sony Vaio",
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "VGN-"),
 		},
 	},
 	{ }
 };
 static int __init sonypi_init(void)
 {
 	int error;
 	printk(KERN_INFO
 		"sonypi: Sony Programmable I/O Controller Driver v%s.\n",
 		SONYPI_DRIVER_VERSION);
 	if (!dmi_check_system(sonypi_dmi_table))
 		return -ENODEV;
 	error = platform_driver_register(&sonypi_driver);
 	if (error)
 		return error;
 	sonypi_platform_device = platform_device_alloc("sonypi", -1);
 	if (!sonypi_platform_device) {
 		error = -ENOMEM;
 		goto err_driver_unregister;
 	}
 	error = platform_device_add(sonypi_platform_device);
 	if (error)
 		goto err_free_device;
 #ifdef CONFIG_ACPI
 	if (acpi_bus_register_driver(&sonypi_acpi_driver) >= 0)
 		acpi_driver_registered = 1;
 #endif
 	return 0;
  err_free_device:
 	platform_device_put(sonypi_platform_device);
  err_driver_unregister:
 	platform_driver_unregister(&sonypi_driver);
 	return error;
 }
 static void __exit sonypi_exit(void)
 {
 #ifdef CONFIG_ACPI
 	if (acpi_driver_registered)
 		acpi_bus_unregister_driver(&sonypi_acpi_driver);
 #endif
 	platform_device_unregister(sonypi_platform_device);
 	platform_driver_unregister(&sonypi_driver);
 	printk(KERN_INFO "sonypi: removed.\n");
 }
 module_init(sonypi_init);
 module_exit(sonypi_exit);

drivers/net/wan/c101.c

Diff comments View file @ 86ae13b

 /*
  * Moxa C101 synchronous serial card driver for Linux
  *
  * Copyright (C) 2000-2003 Krzysztof Halasa <khc@pm.waw.pl>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License
  * as published by the Free Software Foundation.
  *
  * For information see <http://www.kernel.org/pub/linux/utils/net/hdlc/>
  *
  * Sources of information:
  *    Hitachi HD64570 SCA User's Manual
  *    Moxa C101 User's Manual
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/capability.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/moduleparam.h>
 #include <linux/netdevice.h>
 #include <linux/hdlc.h>
 #include <linux/delay.h>
 #include <asm/io.h>
 #include "hd64570.h"
 static const char* version = "Moxa C101 driver version: 1.15";
 static const char* devname = "C101";
 #undef DEBUG_PKT
 #define DEBUG_RINGS
 #define C101_PAGE 0x1D00
 #define C101_DTR 0x1E00
 #define C101_SCA 0x1F00
 #define C101_WINDOW_SIZE 0x2000
 #define C101_MAPPED_RAM_SIZE 0x4000
 #define RAM_SIZE (256 * 1024)
 #define TX_RING_BUFFERS 10
 #define RX_RING_BUFFERS ((RAM_SIZE - C101_WINDOW_SIZE) /		\
 			 (sizeof(pkt_desc) + HDLC_MAX_MRU) - TX_RING_BUFFERS)
 #define CLOCK_BASE 9830400	/* 9.8304 MHz */
 #define PAGE0_ALWAYS_MAPPED
 static char *hw;		/* pointer to hw=xxx command line string */
 typedef struct card_s {
 	struct net_device *dev;
 	spinlock_t lock;	/* TX lock */
 	u8 __iomem *win0base;	/* ISA window base address */
 	u32 phy_winbase;	/* ISA physical base address */
 	sync_serial_settings settings;
 	int rxpart;		/* partial frame received, next frame invalid*/
 	unsigned short encoding;
 	unsigned short parity;
 	u16 rx_ring_buffers;	/* number of buffers in a ring */
 	u16 tx_ring_buffers;
 	u16 buff_offset;	/* offset of first buffer of first channel */
 	u16 rxin;		/* rx ring buffer 'in' pointer */
 	u16 txin;		/* tx ring buffer 'in' and 'last' pointers */
 	u16 txlast;
 	u8 rxs, txs, tmc;	/* SCA registers */
 	u8 irq;			/* IRQ (3-15) */
 	u8 page;
 	struct card_s *next_card;
 }card_t;
 typedef card_t port_t;
 static card_t *first_card;
 static card_t **new_card = &first_card;
 #define sca_in(reg, card)	   readb((card)->win0base + C101_SCA + (reg))
 #define sca_out(value, reg, card)  writeb(value, (card)->win0base + C101_SCA + (reg))
 #define sca_inw(reg, card)	   readw((card)->win0base + C101_SCA + (reg))
 /* EDA address register must be set in EDAL, EDAH order - 8 bit ISA bus */
 #define sca_outw(value, reg, card) do { \
 	writeb(value & 0xFF, (card)->win0base + C101_SCA + (reg)); \
 	writeb((value >> 8 ) & 0xFF, (card)->win0base + C101_SCA + (reg + 1));\
 } while(0)
 #define port_to_card(port)	   (port)
 #define log_node(port)		   (0)
 #define phy_node(port)		   (0)
 #define winsize(card)		   (C101_WINDOW_SIZE)
 #define win0base(card)		   ((card)->win0base)
 #define winbase(card)      	   ((card)->win0base + 0x2000)
 #define get_port(card, port)	   (card)
 static void sca_msci_intr(port_t *port);
 static inline u8 sca_get_page(card_t *card)
 {
 	return card->page;
 }
 static inline void openwin(card_t *card, u8 page)
 {
 	card->page = page;
 	writeb(page, card->win0base + C101_PAGE);
 }
 #include "hd64570.c"
 static inline void set_carrier(port_t *port)
 {
 	if (!(sca_in(MSCI1_OFFSET + ST3, port) & ST3_DCD))
 		netif_carrier_on(port_to_dev(port));
 	else
 		netif_carrier_off(port_to_dev(port));
 }
 static void sca_msci_intr(port_t *port)
 {
 	u8 stat = sca_in(MSCI0_OFFSET + ST1, port); /* read MSCI ST1 status */
 	/* Reset MSCI TX underrun and CDCD (ignored) status bit */
 	sca_out(stat & (ST1_UDRN | ST1_CDCD), MSCI0_OFFSET + ST1, port);
 	if (stat & ST1_UDRN) {
 		/* TX Underrun error detected */
 		port_to_dev(port)->stats.tx_errors++;
 		port_to_dev(port)->stats.tx_fifo_errors++;
 	}
 	stat = sca_in(MSCI1_OFFSET + ST1, port); /* read MSCI1 ST1 status */
 	/* Reset MSCI CDCD status bit - uses ch#2 DCD input */
 	sca_out(stat & ST1_CDCD, MSCI1_OFFSET + ST1, port);
 	if (stat & ST1_CDCD)
 		set_carrier(port);
 }
 static void c101_set_iface(port_t *port)
 {
 	u8 rxs = port->rxs & CLK_BRG_MASK;
 	u8 txs = port->txs & CLK_BRG_MASK;
 	switch(port->settings.clock_type) {
 	case CLOCK_INT:
 		rxs |= CLK_BRG_RX; /* TX clock */
 		txs |= CLK_RXCLK_TX; /* BRG output */
 		break;
 	case CLOCK_TXINT:
 		rxs |= CLK_LINE_RX; /* RXC input */
 		txs |= CLK_BRG_TX; /* BRG output */
 		break;
 	case CLOCK_TXFROMRX:
 		rxs |= CLK_LINE_RX; /* RXC input */
 		txs |= CLK_RXCLK_TX; /* RX clock */
 		break;
 	default:	/* EXTernal clock */
 		rxs |= CLK_LINE_RX; /* RXC input */
 		txs |= CLK_LINE_TX; /* TXC input */
 	}
 	port->rxs = rxs;
 	port->txs = txs;
 	sca_out(rxs, MSCI1_OFFSET + RXS, port);
 	sca_out(txs, MSCI1_OFFSET + TXS, port);
 	sca_set_port(port);
 }
 static int c101_open(struct net_device *dev)
 {
 	port_t *port = dev_to_port(dev);
 	int result;
 	result = hdlc_open(dev);
 	if (result)
 		return result;
 	writeb(1, port->win0base + C101_DTR);
 	sca_out(0, MSCI1_OFFSET + CTL, port); /* RTS uses ch#2 output */
 	sca_open(dev);
 	/* DCD is connected to port 2 !@#$%^& - disable MSCI0 CDCD interrupt */
 	sca_out(IE1_UDRN, MSCI0_OFFSET + IE1, port);
 	sca_out(IE0_TXINT, MSCI0_OFFSET + IE0, port);
 	set_carrier(port);
 	/* enable MSCI1 CDCD interrupt */
 	sca_out(IE1_CDCD, MSCI1_OFFSET + IE1, port);
 	sca_out(IE0_RXINTA, MSCI1_OFFSET + IE0, port);
 	sca_out(0x48, IER0, port); /* TXINT #0 and RXINT #1 */
 	c101_set_iface(port);
 	return 0;
 }
 static int c101_close(struct net_device *dev)
 {
 	port_t *port = dev_to_port(dev);
 	sca_close(dev);
 	writeb(0, port->win0base + C101_DTR);
 	sca_out(CTL_NORTS, MSCI1_OFFSET + CTL, port);
 	hdlc_close(dev);
 	return 0;
 }
 static int c101_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
 	const size_t size = sizeof(sync_serial_settings);
 	sync_serial_settings new_line;
 	sync_serial_settings __user *line = ifr->ifr_settings.ifs_ifsu.sync;
 	port_t *port = dev_to_port(dev);
 #ifdef DEBUG_RINGS
 	if (cmd == SIOCDEVPRIVATE) {
 		sca_dump_rings(dev);
 		printk(KERN_DEBUG "MSCI1: ST: %02x %02x %02x %02x\n",
 		       sca_in(MSCI1_OFFSET + ST0, port),
 		       sca_in(MSCI1_OFFSET + ST1, port),
 		       sca_in(MSCI1_OFFSET + ST2, port),
 		       sca_in(MSCI1_OFFSET + ST3, port));
 		return 0;
 	}
 #endif
 	if (cmd != SIOCWANDEV)
 		return hdlc_ioctl(dev, ifr, cmd);
 	switch(ifr->ifr_settings.type) {
 	case IF_GET_IFACE:
 		ifr->ifr_settings.type = IF_IFACE_SYNC_SERIAL;
 		if (ifr->ifr_settings.size < size) {
 			ifr->ifr_settings.size = size; /* data size wanted */
 			return -ENOBUFS;
 		}
 		if (copy_to_user(line, &port->settings, size))
 			return -EFAULT;
 		return 0;
 	case IF_IFACE_SYNC_SERIAL:
 		if(!capable(CAP_NET_ADMIN))
 			return -EPERM;
 		if (copy_from_user(&new_line, line, size))
 			return -EFAULT;
 		if (new_line.clock_type != CLOCK_EXT &&
 		    new_line.clock_type != CLOCK_TXFROMRX &&
 		    new_line.clock_type != CLOCK_INT &&
 		    new_line.clock_type != CLOCK_TXINT)
 		return -EINVAL;	/* No such clock setting */
 		if (new_line.loopback != 0 && new_line.loopback != 1)
 			return -EINVAL;
 		memcpy(&port->settings, &new_line, size); /* Update settings */
 		c101_set_iface(port);
 		return 0;
 	default:
 		return hdlc_ioctl(dev, ifr, cmd);
 	}
 }
 static void c101_destroy_card(card_t *card)
 {
 	readb(card->win0base + C101_PAGE); /* Resets SCA? */
 	if (card->irq)
 		free_irq(card->irq, card);
 	if (card->win0base) {
 		iounmap(card->win0base);
 		release_mem_region(card->phy_winbase, C101_MAPPED_RAM_SIZE);
 	}
 	free_netdev(card->dev);
 	kfree(card);
 }
 static const struct net_device_ops c101_ops = {
 	.ndo_open       = c101_open,
 	.ndo_stop       = c101_close,
 	.ndo_change_mtu = hdlc_change_mtu,
 	.ndo_start_xmit = hdlc_start_xmit,
 	.ndo_do_ioctl   = c101_ioctl,
 };
 static int __init c101_run(unsigned long irq, unsigned long winbase)
 {
 	struct net_device *dev;
 	hdlc_device *hdlc;
 	card_t *card;
 	int result;
 	if (irq<3 || irq>15 || irq == 6) /* FIXME */ {
 		printk(KERN_ERR "c101: invalid IRQ value\n");
 		return -ENODEV;
 	}
 	if (winbase < 0xC0000 || winbase > 0xDFFFF || (winbase & 0x3FFF) !=0) {
 		printk(KERN_ERR "c101: invalid RAM value\n");
 		return -ENODEV;
 	}
 	card = kzalloc(sizeof(card_t), GFP_KERNEL);
 	if (card == NULL) {
 		printk(KERN_ERR "c101: unable to allocate memory\n");
 		return -ENOBUFS;
 	}
 	card->dev = alloc_hdlcdev(card);
 	if (!card->dev) {
 		printk(KERN_ERR "c101: unable to allocate memory\n");
 		kfree(card);
 		return -ENOBUFS;
 	}
 	if (request_irq(irq, sca_intr, 0, devname, card)) {
 		printk(KERN_ERR "c101: could not allocate IRQ\n");
 		c101_destroy_card(card);
 		return -EBUSY;
 	}
 	card->irq = irq;
 	if (!request_mem_region(winbase, C101_MAPPED_RAM_SIZE, devname)) {
 		printk(KERN_ERR "c101: could not request RAM window\n");
 		c101_destroy_card(card);
 		return -EBUSY;
 	}
 	card->phy_winbase = winbase;
 	card->win0base = ioremap(winbase, C101_MAPPED_RAM_SIZE);
 	if (!card->win0base) {
 		printk(KERN_ERR "c101: could not map I/O address\n");
 		c101_destroy_card(card);
 		return -EFAULT;
 	}
 	card->tx_ring_buffers = TX_RING_BUFFERS;
 	card->rx_ring_buffers = RX_RING_BUFFERS;
 	card->buff_offset = C101_WINDOW_SIZE; /* Bytes 1D00-1FFF reserved */
 	readb(card->win0base + C101_PAGE); /* Resets SCA? */
 	udelay(100);
 	writeb(0, card->win0base + C101_PAGE);
 	writeb(0, card->win0base + C101_DTR); /* Power-up for RAM? */
 	sca_init(card, 0);
 	dev = port_to_dev(card);
 	hdlc = dev_to_hdlc(dev);
 	spin_lock_init(&card->lock);
 	dev->irq = irq;
 	dev->mem_start = winbase;
 	dev->mem_end = winbase + C101_MAPPED_RAM_SIZE - 1;
 	dev->tx_queue_len = 50;
 	dev->netdev_ops = &c101_ops;
 	hdlc->attach = sca_attach;
 	hdlc->xmit = sca_xmit;
 	card->settings.clock_type = CLOCK_EXT;
 	result = register_hdlc_device(dev);
 	if (result) {
 		printk(KERN_WARNING "c101: unable to register hdlc device\n");
 		c101_destroy_card(card);
 		return result;
 	}
 	sca_init_port(card); /* Set up C101 memory */
 	set_carrier(card);
 	printk(KERN_INFO "%s: Moxa C101 on IRQ%u,"
 	       " using %u TX + %u RX packets rings\n",
 	       dev->name, card->irq,
 	       card->tx_ring_buffers, card->rx_ring_buffers);
 	*new_card = card;
 	new_card = &card->next_card;
 	return 0;
 }
 static int __init c101_init(void)
 {
 	if (hw == NULL) {
 #ifdef MODULE
 		printk(KERN_INFO "c101: no card initialized\n");
 #endif
 		return -EINVAL;	/* no parameters specified, abort */
 	}
 	printk(KERN_INFO "%s\n", version);
 	do {
 		unsigned long irq, ram;
 		irq = simple_strtoul(hw, &hw, 0);
 		if (*hw++ != ',')
 			break;
 		ram = simple_strtoul(hw, &hw, 0);
 		if (*hw == ':' || *hw == '\x0')
 			c101_run(irq, ram);
 		if (*hw == '\x0')
 			return first_card ? 0 : -EINVAL;
 	}while(*hw++ == ':');
 	printk(KERN_ERR "c101: invalid hardware parameters\n");
 	return first_card ? 0 : -EINVAL;
 }
 static void __exit c101_cleanup(void)
 {
 	card_t *card = first_card;
 	while (card) {
 		card_t *ptr = card;
 		card = card->next_card;
 		unregister_hdlc_device(port_to_dev(ptr));
 		c101_destroy_card(ptr);
 	}
 }
 module_init(c101_init);
 module_exit(c101_cleanup);
 MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
 MODULE_DESCRIPTION("Moxa C101 serial port driver");
 MODULE_LICENSE("GPL v2");
 module_param(hw, charp, 0444);
 MODULE_PARM_DESC(hw, "irq,ram:irq,...");

drivers/net/wan/n2.c

Diff comments View file @ 86ae13b

 /*
  * SDL Inc. RISCom/N2 synchronous serial card driver for Linux
  *
  * Copyright (C) 1998-2003 Krzysztof Halasa <khc@pm.waw.pl>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License
  * as published by the Free Software Foundation.
  *
  * For information see <http://www.kernel.org/pub/linux/utils/net/hdlc/>
  *
  * Note: integrated CSU/DSU/DDS are not supported by this driver
  *
  * Sources of information:
  *    Hitachi HD64570 SCA User's Manual
  *    SDL Inc. PPP/HDLC/CISCO driver
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/capability.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/in.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/moduleparam.h>
 #include <linux/netdevice.h>
 #include <linux/hdlc.h>
 #include <asm/io.h>
 #include "hd64570.h"
 static const char* version = "SDL RISCom/N2 driver version: 1.15";
 static const char* devname = "RISCom/N2";
 #undef DEBUG_PKT
 #define DEBUG_RINGS
 #define USE_WINDOWSIZE 16384
 #define USE_BUS16BITS 1
 #define CLOCK_BASE 9830400	/* 9.8304 MHz */
 #define MAX_PAGES      16	/* 16 RAM pages at max */
 #define MAX_RAM_SIZE 0x80000	/* 512 KB */
 #if MAX_RAM_SIZE > MAX_PAGES * USE_WINDOWSIZE
 #undef MAX_RAM_SIZE
 #define MAX_RAM_SIZE (MAX_PAGES * USE_WINDOWSIZE)
 #endif
 #define N2_IOPORTS 0x10
 #define NEED_DETECT_RAM
 #define NEED_SCA_MSCI_INTR
 #define MAX_TX_BUFFERS 10
 static char *hw;	/* pointer to hw=xxx command line string */
 /* RISCom/N2 Board Registers */
 /* PC Control Register */
 #define N2_PCR 0
 #define PCR_RUNSCA 1     /* Run 64570 */
 #define PCR_VPM    2     /* Enable VPM - needed if using RAM above 1 MB */
 #define PCR_ENWIN  4     /* Open window */
 #define PCR_BUS16  8     /* 16-bit bus */
 /* Memory Base Address Register */
 #define N2_BAR 2
 /* Page Scan Register  */
 #define N2_PSR 4
 #define WIN16K       0x00
 #define WIN32K       0x20
 #define WIN64K       0x40
 #define PSR_WINBITS  0x60
 #define PSR_DMAEN    0x80
 #define PSR_PAGEBITS 0x0F
 /* Modem Control Reg */
 #define N2_MCR 6
 #define CLOCK_OUT_PORT1 0x80
 #define CLOCK_OUT_PORT0 0x40
 #define TX422_PORT1     0x20
 #define TX422_PORT0     0x10
 #define DSR_PORT1       0x08
 #define DSR_PORT0       0x04
 #define DTR_PORT1       0x02
 #define DTR_PORT0       0x01
 typedef struct port_s {
 	struct net_device *dev;
 	struct card_s *card;
 	spinlock_t lock;	/* TX lock */
 	sync_serial_settings settings;
 	int valid;		/* port enabled */
 	int rxpart;		/* partial frame received, next frame invalid*/
 	unsigned short encoding;
 	unsigned short parity;
 	u16 rxin;		/* rx ring buffer 'in' pointer */
 	u16 txin;		/* tx ring buffer 'in' and 'last' pointers */
 	u16 txlast;
 	u8 rxs, txs, tmc;	/* SCA registers */
 	u8 phy_node;		/* physical port # - 0 or 1 */
 	u8 log_node;		/* logical port # */
 }port_t;
 typedef struct card_s {
 	u8 __iomem *winbase;		/* ISA window base address */
 	u32 phy_winbase;	/* ISA physical base address */
 	u32 ram_size;		/* number of bytes */
 	u16 io;			/* IO Base address */
 	u16 buff_offset;	/* offset of first buffer of first channel */
 	u16 rx_ring_buffers;	/* number of buffers in a ring */
 	u16 tx_ring_buffers;
 	u8 irq;			/* IRQ (3-15) */
 	port_t ports[2];
 	struct card_s *next_card;
 }card_t;
 static card_t *first_card;
 static card_t **new_card = &first_card;
 #define sca_reg(reg, card) (0x8000 | (card)->io | \
 			    ((reg) & 0x0F) | (((reg) & 0xF0) << 6))
 #define sca_in(reg, card)		inb(sca_reg(reg, card))
 #define sca_out(value, reg, card)	outb(value, sca_reg(reg, card))
 #define sca_inw(reg, card)		inw(sca_reg(reg, card))
 #define sca_outw(value, reg, card)	outw(value, sca_reg(reg, card))
 #define port_to_card(port)		((port)->card)
 #define log_node(port)			((port)->log_node)
 #define phy_node(port)			((port)->phy_node)
 #define winsize(card)			(USE_WINDOWSIZE)
 #define winbase(card)      	     	((card)->winbase)
 #define get_port(card, port)		((card)->ports[port].valid ? \
 					 &(card)->ports[port] : NULL)
 static __inline__ u8 sca_get_page(card_t *card)
 {
 	return inb(card->io + N2_PSR) & PSR_PAGEBITS;
 }
 static __inline__ void openwin(card_t *card, u8 page)
 {
 	u8 psr = inb(card->io + N2_PSR);
 	outb((psr & ~PSR_PAGEBITS) | page, card->io + N2_PSR);
 }
 #include "hd64570.c"
 static void n2_set_iface(port_t *port)
 {
 	card_t *card = port->card;
 	int io = card->io;
 	u8 mcr = inb(io + N2_MCR);
 	u8 msci = get_msci(port);
 	u8 rxs = port->rxs & CLK_BRG_MASK;
 	u8 txs = port->txs & CLK_BRG_MASK;
 	switch(port->settings.clock_type) {
 	case CLOCK_INT:
 		mcr |= port->phy_node ? CLOCK_OUT_PORT1 : CLOCK_OUT_PORT0;
 		rxs |= CLK_BRG_RX; /* BRG output */
 		txs |= CLK_RXCLK_TX; /* RX clock */
 		break;
 	case CLOCK_TXINT:
 		mcr |= port->phy_node ? CLOCK_OUT_PORT1 : CLOCK_OUT_PORT0;
 		rxs |= CLK_LINE_RX; /* RXC input */
 		txs |= CLK_BRG_TX; /* BRG output */
 		break;
 	case CLOCK_TXFROMRX:
 		mcr |= port->phy_node ? CLOCK_OUT_PORT1 : CLOCK_OUT_PORT0;
 		rxs |= CLK_LINE_RX; /* RXC input */
 		txs |= CLK_RXCLK_TX; /* RX clock */
 		break;
 	default:		/* Clock EXTernal */
 		mcr &= port->phy_node ? ~CLOCK_OUT_PORT1 : ~CLOCK_OUT_PORT0;
 		rxs |= CLK_LINE_RX; /* RXC input */
 		txs |= CLK_LINE_TX; /* TXC input */
 	}
 	outb(mcr, io + N2_MCR);
 	port->rxs = rxs;
 	port->txs = txs;
 	sca_out(rxs, msci + RXS, card);
 	sca_out(txs, msci + TXS, card);
 	sca_set_port(port);
 }
 static int n2_open(struct net_device *dev)
 {
 	port_t *port = dev_to_port(dev);
 	int io = port->card->io;
 	u8 mcr = inb(io + N2_MCR) | (port->phy_node ? TX422_PORT1:TX422_PORT0);
 	int result;
 	result = hdlc_open(dev);
 	if (result)
 		return result;
 	mcr &= port->phy_node ? ~DTR_PORT1 : ~DTR_PORT0; /* set DTR ON */
 	outb(mcr, io + N2_MCR);
 	outb(inb(io + N2_PCR) | PCR_ENWIN, io + N2_PCR); /* open window */
 	outb(inb(io + N2_PSR) | PSR_DMAEN, io + N2_PSR); /* enable dma */
 	sca_open(dev);
 	n2_set_iface(port);
 	return 0;
 }
 static int n2_close(struct net_device *dev)
 {
 	port_t *port = dev_to_port(dev);
 	int io = port->card->io;
 	u8 mcr = inb(io+N2_MCR) | (port->phy_node ? TX422_PORT1 : TX422_PORT0);
 	sca_close(dev);
 	mcr |= port->phy_node ? DTR_PORT1 : DTR_PORT0; /* set DTR OFF */
 	outb(mcr, io + N2_MCR);
 	hdlc_close(dev);
 	return 0;
 }
 static int n2_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
 	const size_t size = sizeof(sync_serial_settings);
 	sync_serial_settings new_line;
 	sync_serial_settings __user *line = ifr->ifr_settings.ifs_ifsu.sync;
 	port_t *port = dev_to_port(dev);
 #ifdef DEBUG_RINGS
 	if (cmd == SIOCDEVPRIVATE) {
 		sca_dump_rings(dev);
 		return 0;
 	}
 #endif
 	if (cmd != SIOCWANDEV)
 		return hdlc_ioctl(dev, ifr, cmd);
 	switch(ifr->ifr_settings.type) {
 	case IF_GET_IFACE:
 		ifr->ifr_settings.type = IF_IFACE_SYNC_SERIAL;
 		if (ifr->ifr_settings.size < size) {
 			ifr->ifr_settings.size = size; /* data size wanted */
 			return -ENOBUFS;
 		}
 		if (copy_to_user(line, &port->settings, size))
 			return -EFAULT;
 		return 0;
 	case IF_IFACE_SYNC_SERIAL:
 		if(!capable(CAP_NET_ADMIN))
 			return -EPERM;
 		if (copy_from_user(&new_line, line, size))
 			return -EFAULT;
 		if (new_line.clock_type != CLOCK_EXT &&
 		    new_line.clock_type != CLOCK_TXFROMRX &&
 		    new_line.clock_type != CLOCK_INT &&
 		    new_line.clock_type != CLOCK_TXINT)
 		return -EINVAL;	/* No such clock setting */
 		if (new_line.loopback != 0 && new_line.loopback != 1)
 			return -EINVAL;
 		memcpy(&port->settings, &new_line, size); /* Update settings */
 		n2_set_iface(port);
 		return 0;
 	default:
 		return hdlc_ioctl(dev, ifr, cmd);
 	}
 }
 static void n2_destroy_card(card_t *card)
 {
 	int cnt;
 	for (cnt = 0; cnt < 2; cnt++)
 		if (card->ports[cnt].card) {
 			struct net_device *dev = port_to_dev(&card->ports[cnt]);
 			unregister_hdlc_device(dev);
 		}
 	if (card->irq)
 		free_irq(card->irq, card);
 	if (card->winbase) {
 		iounmap(card->winbase);
 		release_mem_region(card->phy_winbase, USE_WINDOWSIZE);
 	}
 	if (card->io)
 		release_region(card->io, N2_IOPORTS);
 	if (card->ports[0].dev)
 		free_netdev(card->ports[0].dev);
 	if (card->ports[1].dev)
 		free_netdev(card->ports[1].dev);
 	kfree(card);
 }
 static const struct net_device_ops n2_ops = {
 	.ndo_open       = n2_open,
 	.ndo_stop       = n2_close,
 	.ndo_change_mtu = hdlc_change_mtu,
 	.ndo_start_xmit = hdlc_start_xmit,
 	.ndo_do_ioctl   = n2_ioctl,
 };
 static int __init n2_run(unsigned long io, unsigned long irq,
 			 unsigned long winbase, long valid0, long valid1)
 {
 	card_t *card;
 	u8 cnt, pcr;
 	int i;
 	if (io < 0x200 || io > 0x3FF || (io % N2_IOPORTS) != 0) {
 		printk(KERN_ERR "n2: invalid I/O port value\n");
 		return -ENODEV;
 	}
 	if (irq < 3 || irq > 15 || irq == 6) /* FIXME */ {
 		printk(KERN_ERR "n2: invalid IRQ value\n");
 		return -ENODEV;
 	}
 	if (winbase < 0xA0000 || winbase > 0xFFFFF || (winbase & 0xFFF) != 0) {
 		printk(KERN_ERR "n2: invalid RAM value\n");
 		return -ENODEV;
 	}
 	card = kzalloc(sizeof(card_t), GFP_KERNEL);
 	if (card == NULL) {
 		printk(KERN_ERR "n2: unable to allocate memory\n");
 		return -ENOBUFS;
 	}
 	card->ports[0].dev = alloc_hdlcdev(&card->ports[0]);
 	card->ports[1].dev = alloc_hdlcdev(&card->ports[1]);
 	if (!card->ports[0].dev || !card->ports[1].dev) {
 		printk(KERN_ERR "n2: unable to allocate memory\n");
 		n2_destroy_card(card);
 		return -ENOMEM;
 	}
 	if (!request_region(io, N2_IOPORTS, devname)) {
 		printk(KERN_ERR "n2: I/O port region in use\n");
 		n2_destroy_card(card);
 		return -EBUSY;
 	}
 	card->io = io;
 	if (request_irq(irq, &sca_intr, 0, devname, card)) {
 		printk(KERN_ERR "n2: could not allocate IRQ\n");
 		n2_destroy_card(card);
 		return(-EBUSY);
 	}
 	card->irq = irq;
 	if (!request_mem_region(winbase, USE_WINDOWSIZE, devname)) {
 		printk(KERN_ERR "n2: could not request RAM window\n");
 		n2_destroy_card(card);
 		return(-EBUSY);
 	}
 	card->phy_winbase = winbase;
 	card->winbase = ioremap(winbase, USE_WINDOWSIZE);
 	if (!card->winbase) {
 		printk(KERN_ERR "n2: ioremap() failed\n");
 		n2_destroy_card(card);
 		return -EFAULT;
 	}
 	outb(0, io + N2_PCR);
 	outb(winbase >> 12, io + N2_BAR);
 	switch (USE_WINDOWSIZE) {
 	case 16384:
 		outb(WIN16K, io + N2_PSR);
 		break;
 	case 32768:
 		outb(WIN32K, io + N2_PSR);
 		break;
 	case 65536:
 		outb(WIN64K, io + N2_PSR);
 		break;
 	default:
 		printk(KERN_ERR "n2: invalid window size\n");
 		n2_destroy_card(card);
 		return -ENODEV;
 	}
 	pcr = PCR_ENWIN | PCR_VPM | (USE_BUS16BITS ? PCR_BUS16 : 0);
 	outb(pcr, io + N2_PCR);
 	card->ram_size = sca_detect_ram(card, card->winbase, MAX_RAM_SIZE);
 	/* number of TX + RX buffers for one port */
 	i = card->ram_size / ((valid0 + valid1) * (sizeof(pkt_desc) +
 						   HDLC_MAX_MRU));
 	card->tx_ring_buffers = min(i / 2, MAX_TX_BUFFERS);
 	card->rx_ring_buffers = i - card->tx_ring_buffers;
 	card->buff_offset = (valid0 + valid1) * sizeof(pkt_desc) *
 		(card->tx_ring_buffers + card->rx_ring_buffers);
 	printk(KERN_INFO "n2: RISCom/N2 %u KB RAM, IRQ%u, "
 	       "using %u TX + %u RX packets rings\n", card->ram_size / 1024,
 	       card->irq, card->tx_ring_buffers, card->rx_ring_buffers);
 	if (card->tx_ring_buffers < 1) {
 		printk(KERN_ERR "n2: RAM test failed\n");
 		n2_destroy_card(card);
 		return -EIO;
 	}
 	pcr |= PCR_RUNSCA;		/* run SCA */
 	outb(pcr, io + N2_PCR);
 	outb(0, io + N2_MCR);
 	sca_init(card, 0);
 	for (cnt = 0; cnt < 2; cnt++) {
 		port_t *port = &card->ports[cnt];
 		struct net_device *dev = port_to_dev(port);
 		hdlc_device *hdlc = dev_to_hdlc(dev);
 		if ((cnt == 0 && !valid0) || (cnt == 1 && !valid1))
 			continue;
 		port->phy_node = cnt;
 		port->valid = 1;
 		if ((cnt == 1) && valid0)
 			port->log_node = 1;
 		spin_lock_init(&port->lock);
 		dev->irq = irq;
 		dev->mem_start = winbase;
 		dev->mem_end = winbase + USE_WINDOWSIZE - 1;
 		dev->tx_queue_len = 50;
 		dev->netdev_ops = &n2_ops;
 		hdlc->attach = sca_attach;
 		hdlc->xmit = sca_xmit;
 		port->settings.clock_type = CLOCK_EXT;
 		port->card = card;
 		if (register_hdlc_device(dev)) {
 			printk(KERN_WARNING "n2: unable to register hdlc "
 			       "device\n");
 			port->card = NULL;
 			n2_destroy_card(card);
 			return -ENOBUFS;
 		}
 		sca_init_port(port); /* Set up SCA memory */
 		printk(KERN_INFO "%s: RISCom/N2 node %d\n",
 		       dev->name, port->phy_node);
 	}
 	*new_card = card;
 	new_card = &card->next_card;
 	return 0;
 }
 static int __init n2_init(void)
 {
 	if (hw==NULL) {
 #ifdef MODULE
 		printk(KERN_INFO "n2: no card initialized\n");
 #endif
 		return -EINVAL;	/* no parameters specified, abort */
 	}
 	printk(KERN_INFO "%s\n", version);
 	do {
 		unsigned long io, irq, ram;
 		long valid[2] = { 0, 0 }; /* Default = both ports disabled */
 		io = simple_strtoul(hw, &hw, 0);
 		if (*hw++ != ',')
 			break;
 		irq = simple_strtoul(hw, &hw, 0);
 		if (*hw++ != ',')
 			break;
 		ram = simple_strtoul(hw, &hw, 0);
 		if (*hw++ != ',')
 			break;
 		while(1) {
 			if (*hw == '0' && !valid[0])
 				valid[0] = 1; /* Port 0 enabled */
 			else if (*hw == '1' && !valid[1])
 				valid[1] = 1; /* Port 1 enabled */
 			else
 				break;
 			hw++;
 		}
 		if (!valid[0] && !valid[1])
 			break;	/* at least one port must be used */
 		if (*hw == ':' || *hw == '\x0')
 			n2_run(io, irq, ram, valid[0], valid[1]);
 		if (*hw == '\x0')
 			return first_card ? 0 : -EINVAL;
 	}while(*hw++ == ':');
 	printk(KERN_ERR "n2: invalid hardware parameters\n");
 	return first_card ? 0 : -EINVAL;
 }
 static void __exit n2_cleanup(void)
 {
 	card_t *card = first_card;
 	while (card) {
 		card_t *ptr = card;
 		card = card->next_card;
 		n2_destroy_card(ptr);
 	}
 }
 module_init(n2_init);
 module_exit(n2_cleanup);
 MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
 MODULE_DESCRIPTION("RISCom/N2 serial port driver");
 MODULE_LICENSE("GPL v2");
 module_param(hw, charp, 0444);
 MODULE_PARM_DESC(hw, "io,irq,ram,ports:io,irq,...");

drivers/net/wan/pci200syn.c

Diff comments View file @ 86ae13b

 /*
  * Goramo PCI200SYN synchronous serial card driver for Linux
  *
  * Copyright (C) 2002-2008 Krzysztof Halasa <khc@pm.waw.pl>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License
  * as published by the Free Software Foundation.
  *
  * For information see <http://www.kernel.org/pub/linux/utils/net/hdlc/>
  *
  * Sources of information:
  *    Hitachi HD64572 SCA-II User's Manual
  *    PLX Technology Inc. PCI9052 Data Book
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/capability.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/in.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/moduleparam.h>
 #include <linux/netdevice.h>
 #include <linux/hdlc.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <asm/io.h>
 #include "hd64572.h"
 #undef DEBUG_PKT
 #define DEBUG_RINGS
 #define PCI200SYN_PLX_SIZE	0x80	/* PLX control window size (128b) */
 #define PCI200SYN_SCA_SIZE	0x400	/* SCA window size (1Kb) */
 #define MAX_TX_BUFFERS		10
 static int pci_clock_freq = 33000000;
 #define CLOCK_BASE pci_clock_freq
 /*
  *      PLX PCI9052 local configuration and shared runtime registers.
  *      This structure can be used to access 9052 registers (memory mapped).
  */
 typedef struct {
 	u32 loc_addr_range[4];	/* 00-0Ch : Local Address Ranges */
 	u32 loc_rom_range;	/* 10h : Local ROM Range */
 	u32 loc_addr_base[4];	/* 14-20h : Local Address Base Addrs */
 	u32 loc_rom_base;	/* 24h : Local ROM Base */
 	u32 loc_bus_descr[4];	/* 28-34h : Local Bus Descriptors */
 	u32 rom_bus_descr;	/* 38h : ROM Bus Descriptor */
 	u32 cs_base[4];		/* 3C-48h : Chip Select Base Addrs */
 	u32 intr_ctrl_stat;	/* 4Ch : Interrupt Control/Status */
 	u32 init_ctrl;		/* 50h : EEPROM ctrl, Init Ctrl, etc */
 }plx9052;
 typedef struct port_s {
 	struct napi_struct napi;
 	struct net_device *netdev;
 	struct card_s *card;
 	spinlock_t lock;	/* TX lock */
 	sync_serial_settings settings;
 	int rxpart;		/* partial frame received, next frame invalid*/
 	unsigned short encoding;
 	unsigned short parity;
 	u16 rxin;		/* rx ring buffer 'in' pointer */
 	u16 txin;		/* tx ring buffer 'in' and 'last' pointers */
 	u16 txlast;
 	u8 rxs, txs, tmc;	/* SCA registers */
 	u8 chan;		/* physical port # - 0 or 1 */
 }port_t;
 typedef struct card_s {
 	u8 __iomem *rambase;	/* buffer memory base (virtual) */
 	u8 __iomem *scabase;	/* SCA memory base (virtual) */
 	plx9052 __iomem *plxbase;/* PLX registers memory base (virtual) */
 	u16 rx_ring_buffers;	/* number of buffers in a ring */
 	u16 tx_ring_buffers;
 	u16 buff_offset;	/* offset of first buffer of first channel */
 	u8 irq;			/* interrupt request level */
 	port_t ports[2];
 }card_t;
 #define get_port(card, port)	     (&card->ports[port])
 #define sca_flush(card)		     (sca_in(IER0, card));
 static inline void new_memcpy_toio(char __iomem *dest, char *src, int length)
 {
 	int len;
 	do {
 		len = length > 256 ? 256 : length;
 		memcpy_toio(dest, src, len);
 		dest += len;
 		src += len;
 		length -= len;
 		readb(dest);
 	} while (len);
 }
 #undef memcpy_toio
 #define memcpy_toio new_memcpy_toio
 #include "hd64572.c"
 static void pci200_set_iface(port_t *port)
 {
 	card_t *card = port->card;
 	u16 msci = get_msci(port);
 	u8 rxs = port->rxs & CLK_BRG_MASK;
 	u8 txs = port->txs & CLK_BRG_MASK;
 	sca_out(EXS_TES1, (port->chan ? MSCI1_OFFSET : MSCI0_OFFSET) + EXS,
 		port->card);
 	switch(port->settings.clock_type) {
 	case CLOCK_INT:
 		rxs |= CLK_BRG; /* BRG output */
 		txs |= CLK_PIN_OUT | CLK_TX_RXCLK; /* RX clock */
 		break;
 	case CLOCK_TXINT:
 		rxs |= CLK_LINE; /* RXC input */
 		txs |= CLK_PIN_OUT | CLK_BRG; /* BRG output */
 		break;
 	case CLOCK_TXFROMRX:
 		rxs |= CLK_LINE; /* RXC input */
 		txs |= CLK_PIN_OUT | CLK_TX_RXCLK; /* RX clock */
 		break;
 	default:		/* EXTernal clock */
 		rxs |= CLK_LINE; /* RXC input */
 		txs |= CLK_PIN_OUT | CLK_LINE; /* TXC input */
 		break;
 	}
 	port->rxs = rxs;
 	port->txs = txs;
 	sca_out(rxs, msci + RXS, card);
 	sca_out(txs, msci + TXS, card);
 	sca_set_port(port);
 }
 static int pci200_open(struct net_device *dev)
 {
 	port_t *port = dev_to_port(dev);
 	int result = hdlc_open(dev);
 	if (result)
 		return result;
 	sca_open(dev);
 	pci200_set_iface(port);
 	sca_flush(port->card);
 	return 0;
 }
 static int pci200_close(struct net_device *dev)
 {
 	sca_close(dev);
 	sca_flush(dev_to_port(dev)->card);
 	hdlc_close(dev);
 	return 0;
 }
 static int pci200_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
 	const size_t size = sizeof(sync_serial_settings);
 	sync_serial_settings new_line;
 	sync_serial_settings __user *line = ifr->ifr_settings.ifs_ifsu.sync;
 	port_t *port = dev_to_port(dev);
 #ifdef DEBUG_RINGS
 	if (cmd == SIOCDEVPRIVATE) {
 		sca_dump_rings(dev);
 		return 0;
 	}
 #endif
 	if (cmd != SIOCWANDEV)
 		return hdlc_ioctl(dev, ifr, cmd);
 	switch(ifr->ifr_settings.type) {
 	case IF_GET_IFACE:
 		ifr->ifr_settings.type = IF_IFACE_V35;
 		if (ifr->ifr_settings.size < size) {
 			ifr->ifr_settings.size = size; /* data size wanted */
 			return -ENOBUFS;
 		}
 		if (copy_to_user(line, &port->settings, size))
 			return -EFAULT;
 		return 0;
 	case IF_IFACE_V35:
 	case IF_IFACE_SYNC_SERIAL:
 		if (!capable(CAP_NET_ADMIN))
 			return -EPERM;
 		if (copy_from_user(&new_line, line, size))
 			return -EFAULT;
 		if (new_line.clock_type != CLOCK_EXT &&
 		    new_line.clock_type != CLOCK_TXFROMRX &&
 		    new_line.clock_type != CLOCK_INT &&
 		    new_line.clock_type != CLOCK_TXINT)
 		return -EINVAL;	/* No such clock setting */
 		if (new_line.loopback != 0 && new_line.loopback != 1)
 			return -EINVAL;
 		memcpy(&port->settings, &new_line, size); /* Update settings */
 		pci200_set_iface(port);
 		sca_flush(port->card);
 		return 0;
 	default:
 		return hdlc_ioctl(dev, ifr, cmd);
 	}
 }
 static void pci200_pci_remove_one(struct pci_dev *pdev)
 {
 	int i;
 	card_t *card = pci_get_drvdata(pdev);
 	for (i = 0; i < 2; i++)
 		if (card->ports[i].card)
 			unregister_hdlc_device(card->ports[i].netdev);
 	if (card->irq)
 		free_irq(card->irq, card);
 	if (card->rambase)
 		iounmap(card->rambase);
 	if (card->scabase)
 		iounmap(card->scabase);
 	if (card->plxbase)
 		iounmap(card->plxbase);
 	pci_release_regions(pdev);
 	pci_disable_device(pdev);
 	pci_set_drvdata(pdev, NULL);
 	if (card->ports[0].netdev)
 		free_netdev(card->ports[0].netdev);
 	if (card->ports[1].netdev)
 		free_netdev(card->ports[1].netdev);
 	kfree(card);
 }
 static const struct net_device_ops pci200_ops = {
 	.ndo_open       = pci200_open,
 	.ndo_stop       = pci200_close,
 	.ndo_change_mtu = hdlc_change_mtu,
 	.ndo_start_xmit = hdlc_start_xmit,
 	.ndo_do_ioctl   = pci200_ioctl,
 };
 static int __devinit pci200_pci_init_one(struct pci_dev *pdev,
 					 const struct pci_device_id *ent)
 {
 	card_t *card;
 	u32 __iomem *p;
 	int i;
 	u32 ramsize;
 	u32 ramphys;		/* buffer memory base */
 	u32 scaphys;		/* SCA memory base */
 	u32 plxphys;		/* PLX registers memory base */
 	i = pci_enable_device(pdev);
 	if (i)
 		return i;
 	i = pci_request_regions(pdev, "PCI200SYN");
 	if (i) {
 		pci_disable_device(pdev);
 		return i;
 	}
 	card = kzalloc(sizeof(card_t), GFP_KERNEL);
 	if (card == NULL) {
 		printk(KERN_ERR "pci200syn: unable to allocate memory\n");
 		pci_release_regions(pdev);
 		pci_disable_device(pdev);
 		return -ENOBUFS;
 	}
 	pci_set_drvdata(pdev, card);
 	card->ports[0].netdev = alloc_hdlcdev(&card->ports[0]);
 	card->ports[1].netdev = alloc_hdlcdev(&card->ports[1]);
 	if (!card->ports[0].netdev || !card->ports[1].netdev) {
 		printk(KERN_ERR "pci200syn: unable to allocate memory\n");
 		pci200_pci_remove_one(pdev);
 		return -ENOMEM;
 	}
 	if (pci_resource_len(pdev, 0) != PCI200SYN_PLX_SIZE ||
 	    pci_resource_len(pdev, 2) != PCI200SYN_SCA_SIZE ||
 	    pci_resource_len(pdev, 3) < 16384) {
 		printk(KERN_ERR "pci200syn: invalid card EEPROM parameters\n");
 		pci200_pci_remove_one(pdev);
 		return -EFAULT;
 	}
 	plxphys = pci_resource_start(pdev,0) & PCI_BASE_ADDRESS_MEM_MASK;
 	card->plxbase = ioremap(plxphys, PCI200SYN_PLX_SIZE);
 	scaphys = pci_resource_start(pdev,2) & PCI_BASE_ADDRESS_MEM_MASK;
 	card->scabase = ioremap(scaphys, PCI200SYN_SCA_SIZE);
 	ramphys = pci_resource_start(pdev,3) & PCI_BASE_ADDRESS_MEM_MASK;
 	card->rambase = pci_ioremap_bar(pdev, 3);
 	if (card->plxbase == NULL ||
 	    card->scabase == NULL ||
 	    card->rambase == NULL) {
 		printk(KERN_ERR "pci200syn: ioremap() failed\n");
 		pci200_pci_remove_one(pdev);
 		return -EFAULT;
 	}
 	/* Reset PLX */
 	p = &card->plxbase->init_ctrl;
 	writel(readl(p) | 0x40000000, p);
 	readl(p);		/* Flush the write - do not use sca_flush */
 	udelay(1);
 	writel(readl(p) & ~0x40000000, p);
 	readl(p);		/* Flush the write - do not use sca_flush */
 	udelay(1);
 	ramsize = sca_detect_ram(card, card->rambase,
 				 pci_resource_len(pdev, 3));
 	/* number of TX + RX buffers for one port - this is dual port card */
 	i = ramsize / (2 * (sizeof(pkt_desc) + HDLC_MAX_MRU));
 	card->tx_ring_buffers = min(i / 2, MAX_TX_BUFFERS);
 	card->rx_ring_buffers = i - card->tx_ring_buffers;
 	card->buff_offset = 2 * sizeof(pkt_desc) * (card->tx_ring_buffers +
 						    card->rx_ring_buffers);
 	printk(KERN_INFO "pci200syn: %u KB RAM at 0x%x, IRQ%u, using %u TX +"
 	       " %u RX packets rings\n", ramsize / 1024, ramphys,
 	       pdev->irq, card->tx_ring_buffers, card->rx_ring_buffers);
 	if (card->tx_ring_buffers < 1) {
 		printk(KERN_ERR "pci200syn: RAM test failed\n");
 		pci200_pci_remove_one(pdev);
 		return -EFAULT;
 	}
 	/* Enable interrupts on the PCI bridge */
 	p = &card->plxbase->intr_ctrl_stat;
 	writew(readw(p) | 0x0040, p);
 	/* Allocate IRQ */
 	if (request_irq(pdev->irq, sca_intr, IRQF_SHARED, "pci200syn", card)) {
 		printk(KERN_WARNING "pci200syn: could not allocate IRQ%d.\n",
 		       pdev->irq);
 		pci200_pci_remove_one(pdev);
 		return -EBUSY;
 	}
 	card->irq = pdev->irq;
 	sca_init(card, 0);
 	for (i = 0; i < 2; i++) {
 		port_t *port = &card->ports[i];
 		struct net_device *dev = port->netdev;
 		hdlc_device *hdlc = dev_to_hdlc(dev);
 		port->chan = i;
 		spin_lock_init(&port->lock);
 		dev->irq = card->irq;
 		dev->mem_start = ramphys;
 		dev->mem_end = ramphys + ramsize - 1;
 		dev->tx_queue_len = 50;
 		dev->netdev_ops = &pci200_ops;
 		hdlc->attach = sca_attach;
 		hdlc->xmit = sca_xmit;
 		port->settings.clock_type = CLOCK_EXT;
 		port->card = card;
 		sca_init_port(port);
 		if (register_hdlc_device(dev)) {
 			printk(KERN_ERR "pci200syn: unable to register hdlc "
 			       "device\n");
 			port->card = NULL;
 			pci200_pci_remove_one(pdev);
 			return -ENOBUFS;
 		}
 		printk(KERN_INFO "%s: PCI200SYN channel %d\n",
 		       dev->name, port->chan);
 	}
 	sca_flush(card);
 	return 0;
 }
 static struct pci_device_id pci200_pci_tbl[] __devinitdata = {
 	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_PLX,
 	  PCI_DEVICE_ID_PLX_PCI200SYN, 0, 0, 0 },
 	{ 0, }
 };
 static struct pci_driver pci200_pci_driver = {
 	.name		= "PCI200SYN",
 	.id_table	= pci200_pci_tbl,
 	.probe		= pci200_pci_init_one,
 	.remove		= pci200_pci_remove_one,
 };
 static int __init pci200_init_module(void)
 {
 	if (pci_clock_freq < 1000000 || pci_clock_freq > 80000000) {
 		printk(KERN_ERR "pci200syn: Invalid PCI clock frequency\n");
 		return -EINVAL;
 	}
 	return pci_register_driver(&pci200_pci_driver);
 }
 static void __exit pci200_cleanup_module(void)
 {
 	pci_unregister_driver(&pci200_pci_driver);
 }
 MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
 MODULE_DESCRIPTION("Goramo PCI200SYN serial port driver");
 MODULE_LICENSE("GPL v2");
 MODULE_DEVICE_TABLE(pci, pci200_pci_tbl);
 module_param(pci_clock_freq, int, 0444);
 MODULE_PARM_DESC(pci_clock_freq, "System PCI clock frequency in Hz");
 module_init(pci200_init_module);
 module_exit(pci200_cleanup_module);

drivers/pci/hotplug/cpqphp.h

Diff comments View file @ 86ae13b

 /*
  * Compaq Hot Plug Controller Driver
  *
  * Copyright (C) 1995,2001 Compaq Computer Corporation
  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
  * Copyright (C) 2001 IBM
  *
  * All rights reserved.
  *
  * 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, GOOD TITLE or
  * NON INFRINGEMENT.  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.
  *
  * Send feedback to <greg@kroah.com>
  *
  */
 #ifndef _CPQPHP_H
 #define _CPQPHP_H
 #include <linux/interrupt.h>
 #include <asm/io.h>		/* for read? and write? functions */
 #include <linux/delay.h>	/* for delays */
 #include <linux/mutex.h>
+#include <linux/sched.h>	/* for signal_pending() */
 #define MY_NAME	"cpqphp"
 #define dbg(fmt, arg...) do { if (cpqhp_debug) printk(KERN_DEBUG "%s: " fmt , MY_NAME , ## arg); } while (0)
 #define err(format, arg...) printk(KERN_ERR "%s: " format , MY_NAME , ## arg)
 #define info(format, arg...) printk(KERN_INFO "%s: " format , MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format , MY_NAME , ## arg)
 struct smbios_system_slot {
 	u8 type;
 	u8 length;
 	u16 handle;
 	u8 name_string_num;
 	u8 slot_type;
 	u8 slot_width;
 	u8 slot_current_usage;
 	u8 slot_length;
 	u16 slot_number;
 	u8 properties1;
 	u8 properties2;
 } __attribute__ ((packed));
 /* offsets to the smbios generic type based on the above structure layout */
 enum smbios_system_slot_offsets {
 	SMBIOS_SLOT_GENERIC_TYPE =	offsetof(struct smbios_system_slot, type),
 	SMBIOS_SLOT_GENERIC_LENGTH =	offsetof(struct smbios_system_slot, length),
 	SMBIOS_SLOT_GENERIC_HANDLE =	offsetof(struct smbios_system_slot, handle),
 	SMBIOS_SLOT_NAME_STRING_NUM =	offsetof(struct smbios_system_slot, name_string_num),
 	SMBIOS_SLOT_TYPE =		offsetof(struct smbios_system_slot, slot_type),
 	SMBIOS_SLOT_WIDTH =		offsetof(struct smbios_system_slot, slot_width),
 	SMBIOS_SLOT_CURRENT_USAGE =	offsetof(struct smbios_system_slot, slot_current_usage),
 	SMBIOS_SLOT_LENGTH =		offsetof(struct smbios_system_slot, slot_length),
 	SMBIOS_SLOT_NUMBER =		offsetof(struct smbios_system_slot, slot_number),
 	SMBIOS_SLOT_PROPERTIES1 =	offsetof(struct smbios_system_slot, properties1),
 	SMBIOS_SLOT_PROPERTIES2 =	offsetof(struct smbios_system_slot, properties2),
 };
 struct smbios_generic {
 	u8 type;
 	u8 length;
 	u16 handle;
 } __attribute__ ((packed));
 /* offsets to the smbios generic type based on the above structure layout */
 enum smbios_generic_offsets {
 	SMBIOS_GENERIC_TYPE =	offsetof(struct smbios_generic, type),
 	SMBIOS_GENERIC_LENGTH =	offsetof(struct smbios_generic, length),
 	SMBIOS_GENERIC_HANDLE =	offsetof(struct smbios_generic, handle),
 };
 struct smbios_entry_point {
 	char anchor[4];
 	u8 ep_checksum;
 	u8 ep_length;
 	u8 major_version;
 	u8 minor_version;
 	u16 max_size_entry;
 	u8 ep_rev;
 	u8 reserved[5];
 	char int_anchor[5];
 	u8 int_checksum;
 	u16 st_length;
 	u32 st_address;
 	u16 number_of_entrys;
 	u8 bcd_rev;
 } __attribute__ ((packed));
 /* offsets to the smbios entry point based on the above structure layout */
 enum smbios_entry_point_offsets {
 	ANCHOR =		offsetof(struct smbios_entry_point, anchor[0]),
 	EP_CHECKSUM =		offsetof(struct smbios_entry_point, ep_checksum),
 	EP_LENGTH =		offsetof(struct smbios_entry_point, ep_length),
 	MAJOR_VERSION =		offsetof(struct smbios_entry_point, major_version),
 	MINOR_VERSION =		offsetof(struct smbios_entry_point, minor_version),
 	MAX_SIZE_ENTRY =	offsetof(struct smbios_entry_point, max_size_entry),
 	EP_REV =		offsetof(struct smbios_entry_point, ep_rev),
 	INT_ANCHOR =		offsetof(struct smbios_entry_point, int_anchor[0]),
 	INT_CHECKSUM =		offsetof(struct smbios_entry_point, int_checksum),
 	ST_LENGTH =		offsetof(struct smbios_entry_point, st_length),
 	ST_ADDRESS =		offsetof(struct smbios_entry_point, st_address),
 	NUMBER_OF_ENTRYS =	offsetof(struct smbios_entry_point, number_of_entrys),
 	BCD_REV =		offsetof(struct smbios_entry_point, bcd_rev),
 };
 struct ctrl_reg {			/* offset */
 	u8	slot_RST;		/* 0x00 */
 	u8	slot_enable;		/* 0x01 */
 	u16	misc;			/* 0x02 */
 	u32	led_control;		/* 0x04 */
 	u32	int_input_clear;	/* 0x08 */
 	u32	int_mask;		/* 0x0a */
 	u8	reserved0;		/* 0x10 */
 	u8	reserved1;		/* 0x11 */
 	u8	reserved2;		/* 0x12 */
 	u8	gen_output_AB;		/* 0x13 */
 	u32	non_int_input;		/* 0x14 */
 	u32	reserved3;		/* 0x18 */
 	u32	reserved4;		/* 0x1a */
 	u32	reserved5;		/* 0x20 */
 	u8	reserved6;		/* 0x24 */
 	u8	reserved7;		/* 0x25 */
 	u16	reserved8;		/* 0x26 */
 	u8	slot_mask;		/* 0x28 */
 	u8	reserved9;		/* 0x29 */
 	u8	reserved10;		/* 0x2a */
 	u8	reserved11;		/* 0x2b */
 	u8	slot_SERR;		/* 0x2c */
 	u8	slot_power;		/* 0x2d */
 	u8	reserved12;		/* 0x2e */
 	u8	reserved13;		/* 0x2f */
 	u8	next_curr_freq;		/* 0x30 */
 	u8	reset_freq_mode;	/* 0x31 */
 } __attribute__ ((packed));
 /* offsets to the controller registers based on the above structure layout */
 enum ctrl_offsets {
 	SLOT_RST =		offsetof(struct ctrl_reg, slot_RST),
 	SLOT_ENABLE =		offsetof(struct ctrl_reg, slot_enable),
 	MISC =			offsetof(struct ctrl_reg, misc),
 	LED_CONTROL =		offsetof(struct ctrl_reg, led_control),
 	INT_INPUT_CLEAR =	offsetof(struct ctrl_reg, int_input_clear),
 	INT_MASK =		offsetof(struct ctrl_reg, int_mask),
 	CTRL_RESERVED0 =	offsetof(struct ctrl_reg, reserved0),
 	CTRL_RESERVED1 =	offsetof(struct ctrl_reg, reserved1),
 	CTRL_RESERVED2 =	offsetof(struct ctrl_reg, reserved1),
 	GEN_OUTPUT_AB =		offsetof(struct ctrl_reg, gen_output_AB),
 	NON_INT_INPUT =		offsetof(struct ctrl_reg, non_int_input),
 	CTRL_RESERVED3 =	offsetof(struct ctrl_reg, reserved3),
 	CTRL_RESERVED4 =	offsetof(struct ctrl_reg, reserved4),
 	CTRL_RESERVED5 =	offsetof(struct ctrl_reg, reserved5),
 	CTRL_RESERVED6 =	offsetof(struct ctrl_reg, reserved6),
 	CTRL_RESERVED7 =	offsetof(struct ctrl_reg, reserved7),
 	CTRL_RESERVED8 =	offsetof(struct ctrl_reg, reserved8),
 	SLOT_MASK =		offsetof(struct ctrl_reg, slot_mask),
 	CTRL_RESERVED9 =	offsetof(struct ctrl_reg, reserved9),
 	CTRL_RESERVED10 =	offsetof(struct ctrl_reg, reserved10),
 	CTRL_RESERVED11 =	offsetof(struct ctrl_reg, reserved11),
 	SLOT_SERR =		offsetof(struct ctrl_reg, slot_SERR),
 	SLOT_POWER =		offsetof(struct ctrl_reg, slot_power),
 	NEXT_CURR_FREQ =	offsetof(struct ctrl_reg, next_curr_freq),
 	RESET_FREQ_MODE =	offsetof(struct ctrl_reg, reset_freq_mode),
 };
 struct hrt {
 	char sig0;
 	char sig1;
 	char sig2;
 	char sig3;
 	u16 unused_IRQ;
 	u16 PCIIRQ;
 	u8 number_of_entries;
 	u8 revision;
 	u16 reserved1;
 	u32 reserved2;
 } __attribute__ ((packed));
 /* offsets to the hotplug resource table registers based on the above
  * structure layout
  */
 enum hrt_offsets {
 	SIG0 =			offsetof(struct hrt, sig0),
 	SIG1 =			offsetof(struct hrt, sig1),
 	SIG2 =			offsetof(struct hrt, sig2),
 	SIG3 =			offsetof(struct hrt, sig3),
 	UNUSED_IRQ =		offsetof(struct hrt, unused_IRQ),
 	PCIIRQ =		offsetof(struct hrt, PCIIRQ),
 	NUMBER_OF_ENTRIES =	offsetof(struct hrt, number_of_entries),
 	REVISION =		offsetof(struct hrt, revision),
 	HRT_RESERVED1 =		offsetof(struct hrt, reserved1),
 	HRT_RESERVED2 =		offsetof(struct hrt, reserved2),
 };
 struct slot_rt {
 	u8 dev_func;
 	u8 primary_bus;
 	u8 secondary_bus;
 	u8 max_bus;
 	u16 io_base;
 	u16 io_length;
 	u16 mem_base;
 	u16 mem_length;
 	u16 pre_mem_base;
 	u16 pre_mem_length;
 } __attribute__ ((packed));
 /* offsets to the hotplug slot resource table registers based on the above
  * structure layout
  */
 enum slot_rt_offsets {
 	DEV_FUNC =		offsetof(struct slot_rt, dev_func),
 	PRIMARY_BUS =		offsetof(struct slot_rt, primary_bus),
 	SECONDARY_BUS =		offsetof(struct slot_rt, secondary_bus),
 	MAX_BUS =		offsetof(struct slot_rt, max_bus),
 	IO_BASE =		offsetof(struct slot_rt, io_base),
 	IO_LENGTH =		offsetof(struct slot_rt, io_length),
 	MEM_BASE =		offsetof(struct slot_rt, mem_base),
 	MEM_LENGTH =		offsetof(struct slot_rt, mem_length),
 	PRE_MEM_BASE =		offsetof(struct slot_rt, pre_mem_base),
 	PRE_MEM_LENGTH =	offsetof(struct slot_rt, pre_mem_length),
 };
 struct pci_func {
 	struct pci_func *next;
 	u8 bus;
 	u8 device;
 	u8 function;
 	u8 is_a_board;
 	u16 status;
 	u8 configured;
 	u8 switch_save;
 	u8 presence_save;
 	u32 base_length[0x06];
 	u8 base_type[0x06];
 	u16 reserved2;
 	u32 config_space[0x20];
 	struct pci_resource *mem_head;
 	struct pci_resource *p_mem_head;
 	struct pci_resource *io_head;
 	struct pci_resource *bus_head;
 	struct timer_list *p_task_event;
 	struct pci_dev* pci_dev;
 };
 struct slot {
 	struct slot *next;
 	u8 bus;
 	u8 device;
 	u8 number;
 	u8 is_a_board;
 	u8 configured;
 	u8 state;
 	u8 switch_save;
 	u8 presence_save;
 	u32 capabilities;
 	u16 reserved2;
 	struct timer_list task_event;
 	u8 hp_slot;
 	struct controller *ctrl;
 	void __iomem *p_sm_slot;
 	struct hotplug_slot *hotplug_slot;
 };
 struct pci_resource {
 	struct pci_resource * next;
 	u32 base;
 	u32 length;
 };
 struct event_info {
 	u32 event_type;
 	u8 hp_slot;
 };
 struct controller {
 	struct controller *next;
 	u32 ctrl_int_comp;
 	struct mutex crit_sect;	/* critical section mutex */
 	void __iomem *hpc_reg;	/* cookie for our pci controller location */
 	struct pci_resource *mem_head;
 	struct pci_resource *p_mem_head;
 	struct pci_resource *io_head;
 	struct pci_resource *bus_head;
 	struct pci_dev *pci_dev;
 	struct pci_bus *pci_bus;
 	struct event_info event_queue[10];
 	struct slot *slot;
 	u8 next_event;
 	u8 interrupt;
 	u8 cfgspc_irq;
 	u8 bus;			/* bus number for the pci hotplug controller */
 	u8 rev;
 	u8 slot_device_offset;
 	u8 first_slot;
 	u8 add_support;
 	u8 push_flag;
 	enum pci_bus_speed speed;
 	enum pci_bus_speed speed_capability;
 	u8 push_button;			/* 0 = no pushbutton, 1 = pushbutton present */
 	u8 slot_switch_type;		/* 0 = no switch, 1 = switch present */
 	u8 defeature_PHP;		/* 0 = PHP not supported, 1 = PHP supported */
 	u8 alternate_base_address;	/* 0 = not supported, 1 = supported */
 	u8 pci_config_space;		/* Index/data access to working registers 0 = not supported, 1 = supported */
 	u8 pcix_speed_capability;	/* PCI-X */
 	u8 pcix_support;		/* PCI-X */
 	u16 vendor_id;
 	struct work_struct int_task_event;
 	wait_queue_head_t queue;	/* sleep & wake process */
 	struct dentry *dentry;		/* debugfs dentry */
 };
 struct irq_mapping {
 	u8 barber_pole;
 	u8 valid_INT;
 	u8 interrupt[4];
 };
 struct resource_lists {
 	struct pci_resource *mem_head;
 	struct pci_resource *p_mem_head;
 	struct pci_resource *io_head;
 	struct pci_resource *bus_head;
 	struct irq_mapping *irqs;
 };
 #define ROM_PHY_ADDR			0x0F0000
 #define ROM_PHY_LEN			0x00ffff
 #define PCI_HPC_ID			0xA0F7
 #define PCI_SUB_HPC_ID			0xA2F7
 #define PCI_SUB_HPC_ID2			0xA2F8
 #define PCI_SUB_HPC_ID3			0xA2F9
 #define PCI_SUB_HPC_ID_INTC		0xA2FA
 #define PCI_SUB_HPC_ID4			0xA2FD
 #define INT_BUTTON_IGNORE		0
 #define INT_PRESENCE_ON			1
 #define INT_PRESENCE_OFF		2
 #define INT_SWITCH_CLOSE		3
 #define INT_SWITCH_OPEN			4
 #define INT_POWER_FAULT			5
 #define INT_POWER_FAULT_CLEAR		6
 #define INT_BUTTON_PRESS		7
 #define INT_BUTTON_RELEASE		8
 #define INT_BUTTON_CANCEL		9
 #define STATIC_STATE			0
 #define BLINKINGON_STATE		1
 #define BLINKINGOFF_STATE		2
 #define POWERON_STATE			3
 #define POWEROFF_STATE			4
 #define PCISLOT_INTERLOCK_CLOSED	0x00000001
 #define PCISLOT_ADAPTER_PRESENT		0x00000002
 #define PCISLOT_POWERED			0x00000004
 #define PCISLOT_66_MHZ_OPERATION	0x00000008
 #define PCISLOT_64_BIT_OPERATION	0x00000010
 #define PCISLOT_REPLACE_SUPPORTED	0x00000020
 #define PCISLOT_ADD_SUPPORTED		0x00000040
 #define PCISLOT_INTERLOCK_SUPPORTED	0x00000080
 #define PCISLOT_66_MHZ_SUPPORTED	0x00000100
 #define PCISLOT_64_BIT_SUPPORTED	0x00000200
 #define PCI_TO_PCI_BRIDGE_CLASS		0x00060400
 #define INTERLOCK_OPEN			0x00000002
 #define ADD_NOT_SUPPORTED		0x00000003
 #define CARD_FUNCTIONING		0x00000005
 #define ADAPTER_NOT_SAME		0x00000006
 #define NO_ADAPTER_PRESENT		0x00000009
 #define NOT_ENOUGH_RESOURCES		0x0000000B
 #define DEVICE_TYPE_NOT_SUPPORTED	0x0000000C
 #define POWER_FAILURE			0x0000000E
 #define REMOVE_NOT_SUPPORTED		0x00000003
 /*
  * error Messages
  */
 #define msg_initialization_err	"Initialization failure, error=%d\n"
 #define msg_HPC_rev_error	"Unsupported revision of the PCI hot plug controller found.\n"
 #define msg_HPC_non_compaq_or_intel	"The PCI hot plug controller is not supported by this driver.\n"
 #define msg_HPC_not_supported	"this system is not supported by this version of cpqphpd. Upgrade to a newer version of cpqphpd\n"
 #define msg_unable_to_save	"unable to store PCI hot plug add resource information. This system must be rebooted before adding any PCI devices.\n"
 #define msg_button_on		"PCI slot #%d - powering on due to button press.\n"
 #define msg_button_off		"PCI slot #%d - powering off due to button press.\n"
 #define msg_button_cancel	"PCI slot #%d - action canceled due to button press.\n"
 #define msg_button_ignore	"PCI slot #%d - button press ignored.  (action in progress...)\n"
 /* debugfs functions for the hotplug controller info */
 extern void cpqhp_initialize_debugfs(void);
 extern void cpqhp_shutdown_debugfs(void);
 extern void cpqhp_create_debugfs_files(struct controller *ctrl);
 extern void cpqhp_remove_debugfs_files(struct controller *ctrl);
 /* controller functions */
 extern void cpqhp_pushbutton_thread(unsigned long event_pointer);
 extern irqreturn_t cpqhp_ctrl_intr(int IRQ, void *data);
 extern int cpqhp_find_available_resources(struct controller *ctrl,
 					  void __iomem *rom_start);
 extern int cpqhp_event_start_thread(void);
 extern void cpqhp_event_stop_thread(void);
 extern struct pci_func *cpqhp_slot_create(unsigned char busnumber);
 extern struct pci_func *cpqhp_slot_find(unsigned char bus, unsigned char device,
 					unsigned char index);
 extern int cpqhp_process_SI(struct controller *ctrl, struct pci_func *func);
 extern int cpqhp_process_SS(struct controller *ctrl, struct pci_func *func);
 extern int cpqhp_hardware_test(struct controller *ctrl, int test_num);
 /* resource functions */
 extern int	cpqhp_resource_sort_and_combine	(struct pci_resource **head);
 /* pci functions */
 extern int cpqhp_set_irq(u8 bus_num, u8 dev_num, u8 int_pin, u8 irq_num);
 extern int cpqhp_get_bus_dev(struct controller *ctrl, u8 *bus_num, u8 *dev_num,
 			     u8 slot);
 extern int cpqhp_save_config(struct controller *ctrl, int busnumber,
 			     int is_hot_plug);
 extern int cpqhp_save_base_addr_length(struct controller *ctrl,
 				       struct pci_func *func);
 extern int cpqhp_save_used_resources(struct controller *ctrl,
 				     struct pci_func *func);
 extern int cpqhp_configure_board(struct controller *ctrl,
 				 struct pci_func *func);
 extern int cpqhp_save_slot_config(struct controller *ctrl,
 				  struct pci_func *new_slot);
 extern int cpqhp_valid_replace(struct controller *ctrl, struct pci_func *func);
 extern void cpqhp_destroy_board_resources(struct pci_func *func);
 extern int cpqhp_return_board_resources	(struct pci_func *func,
 					 struct resource_lists *resources);
 extern void cpqhp_destroy_resource_list(struct resource_lists *resources);
 extern int cpqhp_configure_device(struct controller *ctrl,
 				  struct pci_func *func);
 extern int cpqhp_unconfigure_device(struct pci_func *func);
 /* Global variables */
 extern int cpqhp_debug;
 extern int cpqhp_legacy_mode;
 extern struct controller *cpqhp_ctrl_list;
 extern struct pci_func *cpqhp_slot_list[256];
 extern struct irq_routing_table *cpqhp_routing_table;
 /* these can be gotten rid of, but for debugging they are purty */
 extern u8 cpqhp_nic_irq;
 extern u8 cpqhp_disk_irq;
 /* inline functions */
 static inline const char *slot_name(struct slot *slot)
 {
 	return hotplug_slot_name(slot->hotplug_slot);
 }
 /*
  * return_resource
  *
  * Puts node back in the resource list pointed to by head
  */
 static inline void return_resource(struct pci_resource **head,
 				   struct pci_resource *node)
 {
 	if (!node || !head)
 		return;
 	node->next = *head;
 	*head = node;
 }
 static inline void set_SOGO(struct controller *ctrl)
 {
 	u16 misc;
 	misc = readw(ctrl->hpc_reg + MISC);
 	misc = (misc | 0x0001) & 0xFFFB;
 	writew(misc, ctrl->hpc_reg + MISC);
 }
 static inline void amber_LED_on(struct controller *ctrl, u8 slot)
 {
 	u32 led_control;
 	led_control = readl(ctrl->hpc_reg + LED_CONTROL);
 	led_control |= (0x01010000L << slot);
 	writel(led_control, ctrl->hpc_reg + LED_CONTROL);
 }
 static inline void amber_LED_off(struct controller *ctrl, u8 slot)
 {
 	u32 led_control;
 	led_control = readl(ctrl->hpc_reg + LED_CONTROL);
 	led_control &= ~(0x01010000L << slot);
 	writel(led_control, ctrl->hpc_reg + LED_CONTROL);
 }
 static inline int read_amber_LED(struct controller *ctrl, u8 slot)
 {
 	u32 led_control;
 	led_control = readl(ctrl->hpc_reg + LED_CONTROL);
 	led_control &= (0x01010000L << slot);
 	return led_control ? 1 : 0;
 }
 static inline void green_LED_on(struct controller *ctrl, u8 slot)
 {
 	u32 led_control;
 	led_control = readl(ctrl->hpc_reg + LED_CONTROL);
 	led_control |= 0x0101L << slot;
 	writel(led_control, ctrl->hpc_reg + LED_CONTROL);
 }
 static inline void green_LED_off(struct controller *ctrl, u8 slot)
 {
 	u32 led_control;
 	led_control = readl(ctrl->hpc_reg + LED_CONTROL);
 	led_control &= ~(0x0101L << slot);
 	writel(led_control, ctrl->hpc_reg + LED_CONTROL);
 }
 static inline void green_LED_blink(struct controller *ctrl, u8 slot)
 {
 	u32 led_control;
 	led_control = readl(ctrl->hpc_reg + LED_CONTROL);
 	led_control &= ~(0x0101L << slot);
 	led_control |= (0x0001L << slot);
 	writel(led_control, ctrl->hpc_reg + LED_CONTROL);
 }
 static inline void slot_disable(struct controller *ctrl, u8 slot)
 {
 	u8 slot_enable;
 	slot_enable = readb(ctrl->hpc_reg + SLOT_ENABLE);
 	slot_enable &= ~(0x01 << slot);
 	writeb(slot_enable, ctrl->hpc_reg + SLOT_ENABLE);
 }
 static inline void slot_enable(struct controller *ctrl, u8 slot)
 {
 	u8 slot_enable;
 	slot_enable = readb(ctrl->hpc_reg + SLOT_ENABLE);
 	slot_enable |= (0x01 << slot);
 	writeb(slot_enable, ctrl->hpc_reg + SLOT_ENABLE);
 }
 static inline u8 is_slot_enabled(struct controller *ctrl, u8 slot)
 {
 	u8 slot_enable;
 	slot_enable = readb(ctrl->hpc_reg + SLOT_ENABLE);
 	slot_enable &= (0x01 << slot);
 	return slot_enable ? 1 : 0;
 }
 static inline u8 read_slot_enable(struct controller *ctrl)
 {
 	return readb(ctrl->hpc_reg + SLOT_ENABLE);
 }
 /**
  * get_controller_speed - find the current frequency/mode of controller.
  *
  * @ctrl: controller to get frequency/mode for.
  *
  * Returns controller speed.
  */
 static inline u8 get_controller_speed(struct controller *ctrl)
 {
 	u8 curr_freq;
 	u16 misc;
 	if (ctrl->pcix_support) {
 		curr_freq = readb(ctrl->hpc_reg + NEXT_CURR_FREQ);
 		if ((curr_freq & 0xB0) == 0xB0)
 			return PCI_SPEED_133MHz_PCIX;
 		if ((curr_freq & 0xA0) == 0xA0)
 			return PCI_SPEED_100MHz_PCIX;
 		if ((curr_freq & 0x90) == 0x90)
 			return PCI_SPEED_66MHz_PCIX;
 		if (curr_freq & 0x10)
 			return PCI_SPEED_66MHz;
 		return PCI_SPEED_33MHz;
 	}
 	misc = readw(ctrl->hpc_reg + MISC);
 	return (misc & 0x0800) ? PCI_SPEED_66MHz : PCI_SPEED_33MHz;
 }
 /**
  * get_adapter_speed - find the max supported frequency/mode of adapter.
  *
  * @ctrl: hotplug controller.
  * @hp_slot: hotplug slot where adapter is installed.
  *
  * Returns adapter speed.
  */
 static inline u8 get_adapter_speed(struct controller *ctrl, u8 hp_slot)
 {
 	u32 temp_dword = readl(ctrl->hpc_reg + NON_INT_INPUT);
 	dbg("slot: %d, PCIXCAP: %8x\n", hp_slot, temp_dword);
 	if (ctrl->pcix_support) {
 		if (temp_dword & (0x10000 << hp_slot))
 			return PCI_SPEED_133MHz_PCIX;
 		if (temp_dword & (0x100 << hp_slot))
 			return PCI_SPEED_66MHz_PCIX;
 	}
 	if (temp_dword & (0x01 << hp_slot))
 		return PCI_SPEED_66MHz;
 	return PCI_SPEED_33MHz;
 }
 static inline void enable_slot_power(struct controller *ctrl, u8 slot)
 {
 	u8 slot_power;
 	slot_power = readb(ctrl->hpc_reg + SLOT_POWER);
 	slot_power |= (0x01 << slot);
 	writeb(slot_power, ctrl->hpc_reg + SLOT_POWER);
 }
 static inline void disable_slot_power(struct controller *ctrl, u8 slot)
 {
 	u8 slot_power;
 	slot_power = readb(ctrl->hpc_reg + SLOT_POWER);
 	slot_power &= ~(0x01 << slot);
 	writeb(slot_power, ctrl->hpc_reg + SLOT_POWER);
 }
 static inline int cpq_get_attention_status(struct controller *ctrl, struct slot *slot)
 {
 	u8 hp_slot;
 	hp_slot = slot->device - ctrl->slot_device_offset;
 	return read_amber_LED(ctrl, hp_slot);
 }
 static inline int get_slot_enabled(struct controller *ctrl, struct slot *slot)
 {
 	u8 hp_slot;
 	hp_slot = slot->device - ctrl->slot_device_offset;
 	return is_slot_enabled(ctrl, hp_slot);
 }
 static inline int cpq_get_latch_status(struct controller *ctrl,
 				       struct slot *slot)
 {
 	u32 status;
 	u8 hp_slot;
 	hp_slot = slot->device - ctrl->slot_device_offset;
 	dbg("%s: slot->device = %d, ctrl->slot_device_offset = %d \n",
 	    __func__, slot->device, ctrl->slot_device_offset);
 	status = (readl(ctrl->hpc_reg + INT_INPUT_CLEAR) & (0x01L << hp_slot));
 	return(status == 0) ? 1 : 0;
 }
 static inline int get_presence_status(struct controller *ctrl,
 				      struct slot *slot)
 {
 	int presence_save = 0;
 	u8 hp_slot;
 	u32 tempdword;
 	hp_slot = slot->device - ctrl->slot_device_offset;
 	tempdword = readl(ctrl->hpc_reg + INT_INPUT_CLEAR);
 	presence_save = (int) ((((~tempdword) >> 23) | ((~tempdword) >> 15))
 				>> hp_slot) & 0x02;
 	return presence_save;
 }
 static inline int wait_for_ctrl_irq(struct controller *ctrl)
 {
         DECLARE_WAITQUEUE(wait, current);
 	int retval = 0;
 	dbg("%s - start\n", __func__);
 	add_wait_queue(&ctrl->queue, &wait);
 	/* Sleep for up to 1 second to wait for the LED to change. */
 	msleep_interruptible(1000);
 	remove_wait_queue(&ctrl->queue, &wait);
 	if (signal_pending(current))
 		retval =  -EINTR;
 	dbg("%s - end\n", __func__);
 	return retval;
 }
 #include <asm/pci_x86.h>
 static inline int cpqhp_routing_table_length(void)
 {
 	BUG_ON(cpqhp_routing_table == NULL);
 	return ((cpqhp_routing_table->size - sizeof(struct irq_routing_table)) /
 		sizeof(struct irq_info));
 }
 #endif