
From: Robert Picco <Robert.Picco@hp.com>

- run through Lindent

- add a writeq and readq for i386.

- changed vm_flags to just VM_IO.


- The drivers/char/Kconfig changes will fix the x86_64 build problem with
  -mm3.  Should this patch be acceptable, then I really need to ask Venki to
  test once more on his i386/HPET hardware to be sure nothing is broken there.


---

 25-akpm/Documentation/filesystems/proc.txt |    2 
 25-akpm/drivers/char/Kconfig               |    5 
 25-akpm/drivers/char/hpet.c                |  591 ++++++++++++++---------------
 25-akpm/include/linux/hpet.h               |   75 +--
 4 files changed, 340 insertions(+), 333 deletions(-)

diff -puN Documentation/filesystems/proc.txt~hpet-driver-updates Documentation/filesystems/proc.txt
--- 25/Documentation/filesystems/proc.txt~hpet-driver-updates	Mon May 17 15:59:44 2004
+++ 25-akpm/Documentation/filesystems/proc.txt	Mon May 17 15:59:44 2004
@@ -201,7 +201,7 @@ Table 1-3: Kernel info in /proc 
  devices     Available devices (block and character)           
  dma         Used DMS channels                                 
  filesystems Supported filesystems                             
- driver	     Various drivers grouped here, currently rtc	(2.4)
+ driver	     Various drivers grouped here, currently rtc (2.4) and hpet (2.6)
  execdomains Execdomains, related to security			(2.4)
  fb	     Frame Buffer devices				(2.4)
  fs	     File system parameters, currently nfs/exports	(2.4)
diff -puN drivers/char/hpet.c~hpet-driver-updates drivers/char/hpet.c
--- 25/drivers/char/hpet.c~hpet-driver-updates	Mon May 17 15:59:44 2004
+++ 25-akpm/drivers/char/hpet.c	Mon May 17 15:59:44 2004
@@ -52,39 +52,60 @@ static spinlock_t hpet_lock = SPIN_LOCK_
 static spinlock_t hpet_task_lock = SPIN_LOCK_UNLOCKED;
 
 struct hpet_dev {
-	struct hpets		*hd_hpets;
-	volatile struct hpet	*hd_hpet;
-	volatile struct hpet_timer
-				*hd_timer;
-	unsigned long		hd_ireqfreq;
-	unsigned long		hd_irqdata;
-	wait_queue_head_t	hd_waitqueue;
-	struct fasync_struct	*hd_async_queue;
-	struct hpet_task	*hd_task;
-	unsigned int		hd_flags;
-	unsigned int		hd_irq;
-	unsigned int		hd_hdwirq;
-	int			hd_minor;
+	struct hpets *hd_hpets;
+	struct hpet *hd_hpet;
+	struct hpet_timer *hd_timer;
+	unsigned long hd_ireqfreq;
+	unsigned long hd_irqdata;
+	wait_queue_head_t hd_waitqueue;
+	struct fasync_struct *hd_async_queue;
+	struct hpet_task *hd_task;
+	unsigned int hd_flags;
+	unsigned int hd_irq;
+	unsigned int hd_hdwirq;
+	int hd_minor;
 };
 
 struct hpets {
-	struct hpets		*hp_next;
-	volatile struct hpet	*hp_hpet;
-	unsigned long		hp_period;
-	unsigned long		hp_delta;
-	unsigned int		hp_ntimer;
-	unsigned int		hp_which;
-	struct hpet_dev		hp_dev[1];
+	struct hpets *hp_next;
+	struct hpet *hp_hpet;
+	unsigned long hp_period;
+	unsigned long hp_delta;
+	unsigned int hp_ntimer;
+	unsigned int hp_which;
+	struct hpet_dev hp_dev[1];
 };
 
 static struct hpets *hpets;
 
 #define	HPET_OPEN		0x0001
-#define	HPET_IE			0x0002			/* interrupt enabled */
+#define	HPET_IE			0x0002	/* interrupt enabled */
 #define	HPET_PERIODIC		0x0004
 
-static irqreturn_t
-hpet_interrupt (int irq, void *data, struct pt_regs *regs)
+#if BITS_PER_LONG == 64
+#define	write_counter(V, MC)	writeq(V, MC)
+#define	read_counter(MC)	readq(MC)
+#else
+#define	write_counter(V, MC) 	writel(V, MC)
+#define	read_counter(MC)	readl(MC)
+#endif
+
+#ifndef readq
+static unsigned long long __inline readq(void *addr)
+{
+	return readl(addr) | (((unsigned long long)readl(addr + 4)) << 32LL);
+}
+#endif
+
+#ifndef writeq
+static void __inline writeq(unsigned long long v, void *addr)
+{
+	writel(v & 0xffffffff, addr);
+	writel(v >> 32, addr + 4);
+}
+#endif
+
+static irqreturn_t hpet_interrupt(int irq, void *data, struct pt_regs *regs)
 {
 	struct hpet_dev *devp;
 	unsigned long isr;
@@ -94,16 +115,21 @@ hpet_interrupt (int irq, void *data, str
 	spin_lock(&hpet_lock);
 	devp->hd_irqdata++;
 
+	/*
+	 * For non-periodic timers, increment the accumulator.
+	 * This has the effect of treating non-periodic like periodic.
+	 */
 	if ((devp->hd_flags & (HPET_IE | HPET_PERIODIC)) == HPET_IE) {
 		unsigned long m, t;
 
 		t = devp->hd_ireqfreq;
-		m = devp->hd_hpet->hpet_mc;
-		devp->hd_timer->hpet_compare = t + m + devp->hd_hpets->hp_delta;
+		m = read_counter(&devp->hd_hpet->hpet_mc);
+		write_counter(t + m + devp->hd_hpets->hp_delta,
+			      &devp->hd_timer->hpet_compare);
 	}
 
 	isr = (1 << (devp - devp->hd_hpets->hp_dev));
-	devp->hd_hpet->hpet_isr = isr;
+	writeq(isr, &devp->hd_hpet->hpet_isr);
 	spin_unlock(&hpet_lock);
 
 	spin_lock(&hpet_task_lock);
@@ -118,21 +144,19 @@ hpet_interrupt (int irq, void *data, str
 	return IRQ_HANDLED;
 }
 
-static struct hpet_dev *
-hpet_minor_to_dev (int minor)
+static struct hpet_dev *hpet_minor_to_dev(int minor)
 {
 	struct hpets *hpetp;
 	int i;
 
 	for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-		for (i = 0; i <  hpetp->hp_ntimer; i++)
+		for (i = 0; i < hpetp->hp_ntimer; i++)
 			if (hpetp->hp_dev[i].hd_minor == minor)
 				return &hpetp->hp_dev[i];
 	return 0;
 }
 
-static int
-hpet_open (struct inode *inode, struct file *file)
+static int hpet_open(struct inode *inode, struct file *file)
 {
 	struct hpet_dev *devp;
 
@@ -142,7 +166,7 @@ hpet_open (struct inode *inode, struct f
 		return -ENODEV;
 
 	spin_lock_irq(&hpet_lock);
-	if (devp->hd_flags &  HPET_OPEN || devp->hd_task) {
+	if (devp->hd_flags & HPET_OPEN || devp->hd_task) {
 		spin_unlock_irq(&hpet_lock);
 		return -EBUSY;
 	}
@@ -156,18 +180,18 @@ hpet_open (struct inode *inode, struct f
 }
 
 static ssize_t
-hpet_read (struct file *file, char *buf, size_t count, loff_t *ppos)
+hpet_read(struct file *file, char *buf, size_t count, loff_t * ppos)
 {
-	DECLARE_WAITQUEUE(wait,current);
+	DECLARE_WAITQUEUE(wait, current);
 	unsigned long data;
-	ssize_t	retval;
-	struct hpet_dev	*devp;
+	ssize_t retval;
+	struct hpet_dev *devp;
 
 	devp = file->private_data;
 	if (!devp->hd_ireqfreq)
 		return -EIO;
 
-	if (count < sizeof (unsigned long))
+	if (count < sizeof(unsigned long))
 		return -EINVAL;
 
 	add_wait_queue(&devp->hd_waitqueue, &wait);
@@ -192,23 +216,22 @@ hpet_read (struct file *file, char *buf,
 
 		schedule();
 
-	} while(1);
+	} while (1);
 
-	retval = put_user(data, (unsigned long *) buf);
+	retval = put_user(data, (unsigned long *)buf);
 	if (!retval)
-		retval = sizeof (unsigned long);
-out:
+		retval = sizeof(unsigned long);
+      out:
 	current->state = TASK_RUNNING;
 	remove_wait_queue(&devp->hd_waitqueue, &wait);
 
 	return retval;
 }
 
-static unsigned int
-hpet_poll (struct file *file, poll_table *wait)
+static unsigned int hpet_poll(struct file *file, poll_table * wait)
 {
 	unsigned long v;
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 
 	devp = file->private_data;
 
@@ -227,13 +250,12 @@ hpet_poll (struct file *file, poll_table
 	return 0;
 }
 
-static int
-hpet_mmap (struct file *file, struct vm_area_struct *vma)
+static int hpet_mmap(struct file *file, struct vm_area_struct *vma)
 {
 #ifdef	CONFIG_HPET_NOMMAP
 	return -ENOSYS;
 #else
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 	unsigned long addr;
 
 	if (((vma->vm_end - vma->vm_start) != PAGE_SIZE) || vma->vm_pgoff)
@@ -243,16 +265,17 @@ hpet_mmap (struct file *file, struct vm_
 		return -EPERM;
 
 	devp = file->private_data;
-	addr = (unsigned long) devp->hd_hpet;
+	addr = (unsigned long)devp->hd_hpet;
 
 	if (addr & (PAGE_SIZE - 1))
 		return -ENOSYS;
 
-	vma->vm_flags |= (VM_IO | VM_SHM | VM_LOCKED);
+	vma->vm_flags |= VM_IO;
 	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 	addr = __pa(addr);
 
-	if (remap_page_range(vma, vma->vm_start, addr, PAGE_SIZE, vma->vm_page_prot)) {
+	if (remap_page_range
+	    (vma, vma->vm_start, addr, PAGE_SIZE, vma->vm_page_prot)) {
 		printk(KERN_ERR "remap_page_range failed in hpet.c\n");
 		return -EAGAIN;
 	}
@@ -261,10 +284,9 @@ hpet_mmap (struct file *file, struct vm_
 #endif
 }
 
-static int
-hpet_fasync (int fd, struct file *file, int on)
+static int hpet_fasync(int fd, struct file *file, int on)
 {
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 
 	devp = file->private_data;
 
@@ -274,18 +296,18 @@ hpet_fasync (int fd, struct file *file, 
 		return -EIO;
 }
 
-static int
-hpet_release (struct inode *inode, struct file *file)
+static int hpet_release(struct inode *inode, struct file *file)
 {
-	struct hpet_dev	*devp;
-	volatile struct hpet_timer *timer;
+	struct hpet_dev *devp;
+	struct hpet_timer *timer;
 
 	devp = file->private_data;
 	timer = devp->hd_timer;
 
 	spin_lock_irq(&hpet_lock);
 
-	timer->hpet_config &= ~Tn_INT_ENB_CNF_MASK;
+	writeq((readq(&timer->hpet_config) & ~Tn_INT_ENB_CNF_MASK),
+	       &timer->hpet_config);
 
 	if (devp->hd_irq) {
 		free_irq(devp->hd_irq, devp);
@@ -294,12 +316,13 @@ hpet_release (struct inode *inode, struc
 
 	devp->hd_ireqfreq = 0;
 
-	if (devp->hd_flags & HPET_PERIODIC && timer->hpet_config & Tn_TYPE_CNF_MASK) {
+	if (devp->hd_flags & HPET_PERIODIC
+	    && readq(&timer->hpet_config) & Tn_TYPE_CNF_MASK) {
 		unsigned long v;
 
-		v = timer->hpet_config;
+		v = readq(&timer->hpet_config);
 		v ^= Tn_TYPE_CNF_MASK;
-		timer->hpet_config = v;
+		writeq(v, &timer->hpet_config);
 	}
 
 	devp->hd_flags &= ~(HPET_OPEN | HPET_IE | HPET_PERIODIC);
@@ -315,19 +338,19 @@ hpet_release (struct inode *inode, struc
 static int hpet_ioctl_common(struct hpet_dev *, int, unsigned long, int);
 
 static int
-hpet_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+hpet_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+	   unsigned long arg)
 {
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 
 	devp = file->private_data;
 	return hpet_ioctl_common(devp, cmd, arg, 0);
 }
 
-static int
-hpet_ioctl_ieon (struct hpet_dev *devp)
+static int hpet_ioctl_ieon(struct hpet_dev *devp)
 {
-	volatile struct hpet_timer *timer;
-	volatile struct hpet *hpet;
+	struct hpet_timer *timer;
+	struct hpet *hpet;
 	struct hpets *hpetp;
 	int irq;
 	unsigned long g, v, t, m;
@@ -337,7 +360,7 @@ hpet_ioctl_ieon (struct hpet_dev *devp)
 	hpet = devp->hd_hpet;
 	hpetp = devp->hd_hpets;
 
-	v = timer->hpet_config;
+	v = readq(&timer->hpet_config);
 	spin_lock_irq(&hpet_lock);
 
 	if (devp->hd_flags & HPET_IE) {
@@ -348,15 +371,16 @@ hpet_ioctl_ieon (struct hpet_dev *devp)
 	devp->hd_flags |= HPET_IE;
 	spin_unlock_irq(&hpet_lock);
 
-	t = timer->hpet_config;
+	t = readq(&timer->hpet_config);
 	irq = devp->hd_hdwirq;
 
 	if (irq) {
 		char name[7];
 
-		sprintf(name, "hpet%d", (int) (devp - hpetp->hp_dev));
+		sprintf(name, "hpet%d", (int)(devp - hpetp->hp_dev));
 
-		if (request_irq(irq, hpet_interrupt, SA_INTERRUPT, name, (void *) devp)) {
+		if (request_irq
+		    (irq, hpet_interrupt, SA_INTERRUPT, name, (void *)devp)) {
 			printk(KERN_ERR "hpet: IRQ %d is not free\n", irq);
 			irq = 0;
 		}
@@ -371,48 +395,47 @@ hpet_ioctl_ieon (struct hpet_dev *devp)
 
 	devp->hd_irq = irq;
 	t = devp->hd_ireqfreq;
-	v = timer->hpet_config;
+	v = readq(&timer->hpet_config);
 	g = v | Tn_INT_ENB_CNF_MASK;
 
 	if (devp->hd_flags & HPET_PERIODIC) {
-		timer->hpet_compare = t;
+		write_counter(t, &timer->hpet_compare);
 		g |= Tn_TYPE_CNF_MASK;
 		v |= Tn_TYPE_CNF_MASK;
-		timer->hpet_config = v;
+		writeq(v, &timer->hpet_config);
 		v |= Tn_VAL_SET_CNF_MASK;
-		timer->hpet_config = v;
+		writeq(v, &timer->hpet_config);
 		local_irq_save(flags);
-		m = hpet->hpet_mc;
-		timer->hpet_compare = t + m + hpetp->hp_delta;
+		m = read_counter(&hpet->hpet_mc);
+		write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
 	} else {
 		local_irq_save(flags);
-		m = hpet->hpet_mc;
-		timer->hpet_compare = t + m + hpetp->hp_delta;
+		m = read_counter(&hpet->hpet_mc);
+		write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
 	}
 
 	isr = (1 << (devp - hpets->hp_dev));
-	hpet->hpet_isr = isr;
-	timer->hpet_config = g;
+	writeq(isr, &hpet->hpet_isr);
+	writeq(g, &timer->hpet_config);
 	local_irq_restore(flags);
 
 	return 0;
 }
 
-static inline unsigned long
-hpet_time_div (unsigned long dis)
+static inline unsigned long hpet_time_div(unsigned long dis)
 {
 	unsigned long long m = 1000000000000000ULL;
 
 	do_div(m, dis);
 
-	return (unsigned long) m;
+	return (unsigned long)m;
 }
 
 static int
-hpet_ioctl_common (struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
+hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
 {
-	volatile struct hpet_timer *timer;
-	volatile struct hpet *hpet;
+	struct hpet_timer *timer;
+	struct hpet *hpet;
 	struct hpets *hpetp;
 	int err;
 	unsigned long v;
@@ -439,9 +462,9 @@ hpet_ioctl_common (struct hpet_dev *devp
 	case HPET_IE_OFF:
 		if ((devp->hd_flags & HPET_IE) == 0)
 			break;
-		v = timer->hpet_config;
+		v = readq(&timer->hpet_config);
 		v &= ~Tn_INT_ENB_CNF_MASK;
-		timer->hpet_config = v;
+		writeq(v, &timer->hpet_config);
 		if (devp->hd_irq) {
 			free_irq(devp->hd_irq, devp);
 			devp->hd_irq = 0;
@@ -449,18 +472,19 @@ hpet_ioctl_common (struct hpet_dev *devp
 		devp->hd_flags ^= HPET_IE;
 		break;
 	case HPET_INFO:
-	{
-		struct hpet_info		info;
+		{
+			struct hpet_info info;
 
-		info.hi_ireqfreq = hpet_time_div(hpetp->hp_period *
-			devp->hd_ireqfreq);
-		info.hi_flags = timer->hpet_config & Tn_PER_INT_CAP_MASK;
-		if (copy_to_user((void *) arg, &info , sizeof (info)))
-			err = -EFAULT;
-		break;
-	}
+			info.hi_ireqfreq = hpet_time_div(hpetp->hp_period *
+							 devp->hd_ireqfreq);
+			info.hi_flags =
+			    readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK;
+			if (copy_to_user((void *)arg, &info, sizeof(info)))
+				err = -EFAULT;
+			break;
+		}
 	case HPET_EPI:
-		v = timer->hpet_config;
+		v = readq(&timer->hpet_config);
 		if ((v & Tn_PER_INT_CAP_MASK) == 0) {
 			err = -ENXIO;
 			break;
@@ -468,22 +492,22 @@ hpet_ioctl_common (struct hpet_dev *devp
 		devp->hd_flags |= HPET_PERIODIC;
 		break;
 	case HPET_DPI:
-		v = timer->hpet_config;
+		v = readq(&timer->hpet_config);
 		if ((v & Tn_PER_INT_CAP_MASK) == 0) {
 			err = -ENXIO;
 			break;
 		}
 		if (devp->hd_flags & HPET_PERIODIC &&
-			timer->hpet_config & Tn_TYPE_CNF_MASK) {
-			v = timer->hpet_config;
+		    readq(&timer->hpet_config) & Tn_TYPE_CNF_MASK) {
+			v = readq(&timer->hpet_config);
 			v ^= Tn_TYPE_CNF_MASK;
-			timer->hpet_config = v;
+			writeq(v, &timer->hpet_config);
 		}
 		devp->hd_flags &= ~HPET_PERIODIC;
 		break;
 	case HPET_IRQFREQ:
 		if (!kernel && (arg > hpet_max_freq) &&
-			!capable(CAP_SYS_RESOURCE)) {
+		    !capable(CAP_SYS_RESOURCE)) {
 			err = -EACCES;
 			break;
 		}
@@ -500,15 +524,15 @@ hpet_ioctl_common (struct hpet_dev *devp
 }
 
 static struct file_operations hpet_fops = {
-	.owner		= THIS_MODULE,
-	.llseek		= no_llseek,
-	.read		= hpet_read,
-	.poll		= hpet_poll,
-	.ioctl		= hpet_ioctl,
-	.open		= hpet_open,
-	.release	= hpet_release,
-	.fasync		= hpet_fasync,
-	.mmap		= hpet_mmap,
+	.owner = THIS_MODULE,
+	.llseek = no_llseek,
+	.read = hpet_read,
+	.poll = hpet_poll,
+	.ioctl = hpet_ioctl,
+	.open = hpet_open,
+	.release = hpet_release,
+	.fasync = hpet_fasync,
+	.mmap = hpet_mmap,
 };
 
 EXPORT_SYMBOL(hpet_alloc);
@@ -516,12 +540,11 @@ EXPORT_SYMBOL(hpet_register);
 EXPORT_SYMBOL(hpet_unregister);
 EXPORT_SYMBOL(hpet_control);
 
-int
-hpet_register (struct hpet_task *tp, int periodic)
+int hpet_register(struct hpet_task *tp, int periodic)
 {
 	unsigned int i;
 	u64 mask;
-	volatile struct hpet_timer *timer;
+	struct hpet_timer *timer;
 	struct hpet_dev *devp;
 	struct hpets *hpetp;
 
@@ -540,21 +563,23 @@ hpet_register (struct hpet_task *tp, int
 	spin_lock(&hpet_lock);
 
 	for (devp = 0, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next)
-	for (timer = hpetp->hp_hpet->hpet_timers, i = 0; i < hpetp->hp_ntimer; i++, timer++) {
-		if ((timer->hpet_config & Tn_PER_INT_CAP_MASK) != mask)
-			continue;
+		for (timer = hpetp->hp_hpet->hpet_timers, i = 0;
+		     i < hpetp->hp_ntimer; i++, timer++) {
+			if ((readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK)
+			    != mask)
+				continue;
 
-		devp = &hpetp->hp_dev[i];
+			devp = &hpetp->hp_dev[i];
 
-		if (devp->hd_flags & HPET_OPEN || devp->hd_task) {
-			devp = 0;
-			continue;
-		}
+			if (devp->hd_flags & HPET_OPEN || devp->hd_task) {
+				devp = 0;
+				continue;
+			}
 
-		tp->ht_opaque = devp;
-		devp->hd_task = tp;
-		break;
-	}
+			tp->ht_opaque = devp;
+			devp->hd_task = tp;
+			break;
+		}
 
 	spin_unlock(&hpet_lock);
 	spin_unlock_irq(&hpet_task_lock);
@@ -565,10 +590,9 @@ hpet_register (struct hpet_task *tp, int
 		return -EBUSY;
 }
 
-static inline int
-hpet_tpcheck (struct hpet_task *tp)
+static inline int hpet_tpcheck(struct hpet_task *tp)
 {
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 	struct hpets *hpetp;
 
 	devp = tp->ht_opaque;
@@ -577,19 +601,18 @@ hpet_tpcheck (struct hpet_task *tp)
 		return -ENXIO;
 
 	for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-		if (devp >= hpetp->hp_dev && devp < (hpetp->hp_dev + hpetp->hp_ntimer) &&
-			devp->hd_hpet == hpetp->hp_hpet)
+		if (devp >= hpetp->hp_dev
+		    && devp < (hpetp->hp_dev + hpetp->hp_ntimer)
+		    && devp->hd_hpet == hpetp->hp_hpet)
 			return 0;
 
 	return -ENXIO;
 }
 
-
-int
-hpet_unregister (struct hpet_task *tp)
+int hpet_unregister(struct hpet_task *tp)
 {
-	struct hpet_dev	*devp;
-	volatile struct hpet_timer *timer;
+	struct hpet_dev *devp;
+	struct hpet_timer *timer;
 	int err;
 
 	if ((err = hpet_tpcheck(tp)))
@@ -606,8 +629,9 @@ hpet_unregister (struct hpet_task *tp)
 	}
 
 	timer = devp->hd_timer;
-	timer->hpet_config &= ~Tn_INT_ENB_CNF_MASK;
-	devp->hd_flags &= ~( HPET_IE | HPET_PERIODIC);
+	writeq((readq(&timer->hpet_config) & ~Tn_INT_ENB_CNF_MASK),
+	       &timer->hpet_config);
+	devp->hd_flags &= ~(HPET_IE | HPET_PERIODIC);
 	devp->hd_task = 0;
 	spin_unlock(&hpet_lock);
 	spin_unlock_irq(&hpet_task_lock);
@@ -615,10 +639,9 @@ hpet_unregister (struct hpet_task *tp)
 	return 0;
 }
 
-int
-hpet_control (struct hpet_task *tp, unsigned int cmd, unsigned long arg)
+int hpet_control(struct hpet_task *tp, unsigned int cmd, unsigned long arg)
 {
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 	int err;
 
 	if ((err = hpet_tpcheck(tp)))
@@ -634,93 +657,83 @@ hpet_control (struct hpet_task *tp, unsi
 	return hpet_ioctl_common(devp, cmd, arg, 1);
 }
 
-
-
 #ifdef	CONFIG_TIME_INTERPOLATION
 
 static unsigned long hpet_offset, last_wall_hpet;
 static long hpet_nsecs_per_cycle, hpet_cycles_per_sec;
 
-static unsigned long
-hpet_getoffset (void)
+static unsigned long hpet_getoffset(void)
 {
-	return hpet_offset + (hpets->hp_hpet->hpet_mc - last_wall_hpet) * hpet_nsecs_per_cycle;
+	return hpet_offset + (read_counter(&hpets->hp_hpet->hpet_mc) -
+			      last_wall_hpet) * hpet_nsecs_per_cycle;
 }
 
-static void
-hpet_update (long delta)
+static void hpet_update(long delta)
 {
 	unsigned long mc;
 	unsigned long offset;
-	volatile struct hpet *hpet;
 
-	hpet = hpets->hp_hpet;
-	mc = hpet->hpet_mc;
+	mc = read_counter(&hpets->hp_hpet->hpet_mc);
 	offset = hpet_offset + (mc - last_wall_hpet) * hpet_nsecs_per_cycle;
 
-	if (delta < 0 || (unsigned long) delta < offset)
+	if (delta < 0 || (unsigned long)delta < offset)
 		hpet_offset = offset - delta;
 	else
 		hpet_offset = 0;
 	last_wall_hpet = mc;
 }
 
-static void
-hpet_reset (void)
+static void hpet_reset(void)
 {
-	volatile struct hpet *hpet;
-
-	hpet = hpets->hp_hpet;
 	hpet_offset = 0;
-	last_wall_hpet = hpet->hpet_mc;
+	last_wall_hpet = read_counter(&hpets->hp_hpet->hpet_mc);
 }
 
 static struct time_interpolator hpet_interpolator = {
-	.get_offset	=	hpet_getoffset,
-	.update		=	hpet_update,
-	.reset		=	hpet_reset
+	.get_offset = hpet_getoffset,
+	.update = hpet_update,
+	.reset = hpet_reset
 };
 
 #endif
 
 static ctl_table hpet_table[] = {
 	{
-		.ctl_name	= 1,
-		.procname	= "max-user-freq",
-		.data		= &hpet_max_freq,
-		.maxlen		= sizeof(int),
-		.mode		= 0644,
-		.proc_handler	= &proc_dointvec,
-	},
-	{ .ctl_name = 0 }
+	 .ctl_name = 1,
+	 .procname = "max-user-freq",
+	 .data = &hpet_max_freq,
+	 .maxlen = sizeof(int),
+	 .mode = 0644,
+	 .proc_handler = &proc_dointvec,
+	 },
+	{.ctl_name = 0}
 };
 
 static ctl_table hpet_root[] = {
 	{
-		.ctl_name	= 1,
-		.procname	= "hpet",
-		.maxlen		= 0,
-		.mode		= 0555,
-		.child		= hpet_table,
-	},
-	{ .ctl_name = 0 }
+	 .ctl_name = 1,
+	 .procname = "hpet",
+	 .maxlen = 0,
+	 .mode = 0555,
+	 .child = hpet_table,
+	 },
+	{.ctl_name = 0}
 };
 
 static ctl_table dev_root[] = {
 	{
-		.ctl_name	= CTL_DEV,
-		.procname	= "dev",
-		.maxlen		= 0,
-		.mode		= 0555,
-		.child		= hpet_root,
-	},
-	{ .ctl_name = 0 }
+	 .ctl_name = CTL_DEV,
+	 .procname = "dev",
+	 .maxlen = 0,
+	 .mode = 0555,
+	 .child = hpet_root,
+	 },
+	{.ctl_name = 0}
 };
 
 static struct ctl_table_header *sysctl_header;
 
-static void *
-hpet_start (struct seq_file *s, loff_t *pos)
+static void *hpet_start(struct seq_file *s, loff_t * pos)
 {
 	struct hpets *hpetp;
 	loff_t n;
@@ -732,8 +745,7 @@ hpet_start (struct seq_file *s, loff_t *
 	return 0;
 }
 
-static void *
-hpet_next (struct seq_file *s, void *v, loff_t *pos)
+static void *hpet_next(struct seq_file *s, void *v, loff_t * pos)
 {
 	struct hpets *hpetp;
 
@@ -742,54 +754,52 @@ hpet_next (struct seq_file *s, void *v, 
 	return hpetp->hp_next;
 }
 
-static void
-hpet_stop (struct seq_file *s, void *v)
+static void hpet_stop(struct seq_file *s, void *v)
 {
 	return;
 }
 
-static int
-hpet_show (struct seq_file *s, void *v)
+static int hpet_show(struct seq_file *s, void *v)
 {
 	struct hpets *hpetp;
-	volatile struct hpet *hpet;
+	struct hpet *hpet;
 	u64 cap, vendor, period;
 
 	hpetp = v;
 	hpet = hpetp->hp_hpet;
 
-	cap = hpet->hpet_cap;
+	cap = readq(&hpet->hpet_cap);
 	period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >>
-		HPET_COUNTER_CLK_PERIOD_SHIFT;
+	    HPET_COUNTER_CLK_PERIOD_SHIFT;
 	vendor = (cap & HPET_VENDOR_ID_MASK) >> HPET_VENDOR_ID_SHIFT;
 
-	seq_printf(s, "HPET%d period = %d 10**-15  vendor = 0x%x number timer = %d\n",
-		hpetp->hp_which, (u32) period, (u32) vendor, hpetp->hp_ntimer);
+	seq_printf(s,
+		   "HPET%d period = %d 10**-15  vendor = 0x%x number timer = %d\n",
+		   hpetp->hp_which, (u32) period, (u32) vendor,
+		   hpetp->hp_ntimer);
 
 	return 0;
 }
 
 static struct seq_operations hpet_seq_ops = {
-	.start	=	hpet_start,
-	.next	=	hpet_next,
-	.stop	=	hpet_stop,
-	.show	=	hpet_show
+	.start = hpet_start,
+	.next = hpet_next,
+	.stop = hpet_stop,
+	.show = hpet_show
 };
 
-static int
-hpet_proc_open (struct inode *inode, struct file *file)
+static int hpet_proc_open(struct inode *inode, struct file *file)
 {
 	return seq_open(file, &hpet_seq_ops);
 }
 
 static struct file_operations hpet_proc_fops = {
-	.open		=	hpet_proc_open,
-	.read		=	seq_read,
-	.llseek		=	seq_lseek,
-	.release	=	seq_release
+	.open = hpet_proc_open,
+	.read = seq_read,
+	.llseek = seq_lseek,
+	.release = seq_release
 };
 
-
 /*
  * Adjustment for when arming the timer with
  * initial conditions.  That is, main counter
@@ -797,16 +807,16 @@ static struct file_operations hpet_proc_
  */
 #define	TICK_CALIBRATE	(1000UL)
 
-static unsigned long __init
-hpet_calibrate (struct hpets *hpetp)
+static unsigned long __init hpet_calibrate(struct hpets *hpetp)
 {
-	volatile struct hpet_timer *timer;
+	struct hpet_timer *timer;
 	unsigned long t, m, count, i, flags, start;
 	struct hpet_dev *devp;
 	int j;
-	volatile struct hpet *hpet;
+	struct hpet *hpet;
 
-	for (timer = 0, j = 0, devp = hpetp->hp_dev;  j < hpetp->hp_ntimer; j++, devp++)
+	for (timer = 0, j = 0, devp = hpetp->hp_dev; j < hpetp->hp_ntimer;
+	     j++, devp++)
 		if ((devp->hd_flags & HPET_OPEN) == 0) {
 			timer = devp->hd_timer;
 			break;
@@ -816,27 +826,26 @@ hpet_calibrate (struct hpets *hpetp)
 		return 0;
 
 	hpet = hpets->hp_hpet;
-	t = timer->hpet_compare;
+	t = read_counter(&timer->hpet_compare);
 
 	i = 0;
 	count = hpet_time_div(hpetp->hp_period * TICK_CALIBRATE);
 
 	local_irq_save(flags);
 
-	start = hpet->hpet_mc;
+	start = read_counter(&hpet->hpet_mc);
 
 	do {
-		m = hpet->hpet_mc;
-		timer->hpet_compare = t + m + hpetp->hp_delta;
-	} while (i++, (m - start) <  count);
+		m = read_counter(&hpet->hpet_mc);
+		write_counter(t + m + hpetp->hp_delta, &timer->hpet_compare);
+	} while (i++, (m - start) < count);
 
 	local_irq_restore(flags);
 
 	return (m - start) / i;
 }
 
-static void __init
-hpet_init_chrdev (void)
+static void __init hpet_init_chrdev(void)
 {
 	static int once;
 
@@ -846,47 +855,51 @@ hpet_init_chrdev (void)
 	return;
 }
 
-static void __init
-hpet_post_platform (void)
+static void __init hpet_post_platform(void)
 {
 	struct hpets *hpetp;
 	u32 i, ntimer;
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 
 	hpet_init_chrdev();
 
 	for (ntimer = 0, hpetp = hpets; hpetp; hpetp = hpetp->hp_next, ntimer++)
-		for (i = 0, devp = hpetp->hp_dev;  i < hpetp->hp_ntimer; i++, devp++) {
+		for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer;
+		     i++, devp++) {
 
 			if (devp->hd_flags & HPET_OPEN)
 				continue;
 
 			sprintf(&hpetname[5], "%d", ntimer);
 			devfs_mk_cdev(MKDEV(HPET_MAJOR, ntimer),
-				S_IFCHR|S_IRUSR|S_IWUSR, hpetname);
+				      S_IFCHR | S_IRUSR | S_IWUSR, hpetname);
 			init_waitqueue_head(&devp->hd_waitqueue);
 		}
 
 	return;
 }
 
-int __init
-hpet_alloc (struct hpet_data *hdp)
+int __init hpet_alloc(struct hpet_data *hdp)
 {
 	u64 cap, mcfg;
-	struct hpet_dev	*devp;
+	struct hpet_dev *devp;
 	u32 i, ntimer;
 	struct hpets *hpetp;
 	size_t siz;
-	volatile struct hpet *hpet;
-	static struct hpets *last __initdata = (struct hpets *) 0;
+	struct hpet *hpet;
+	static struct hpets *last __initdata = (struct hpets *)0;
 
+	/*
+	 * hpet_alloc can be called by platform dependent code.
+	 * if platform dependent code has allocated the hpet
+	 * ACPI also reports hpet, then we catch it here.
+	 */
 	for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-		if (hpetp->hp_hpet == (struct hpet *) (hdp->hd_address))
+		if (hpetp->hp_hpet == (struct hpet *)(hdp->hd_address))
 			return 0;
 
-	siz = sizeof (struct hpets) + ((hdp->hd_nirqs - 1) *
-		sizeof (struct hpet_dev));
+	siz = sizeof(struct hpets) + ((hdp->hd_nirqs - 1) *
+				      sizeof(struct hpet_dev));
 
 	hpetp = kmalloc(siz, GFP_KERNEL);
 
@@ -896,14 +909,7 @@ hpet_alloc (struct hpet_data *hdp)
 	memset(hpetp, 0, siz);
 
 	hpetp->hp_which = hpet_nhpet++;
-	hpetp->hp_hpet = (struct hpet *) hdp->hd_address;
-
-	if (last)
-		last->hp_next = hpetp;
-	else
-		hpets = hpetp;
-
-	last = hpetp;
+	hpetp->hp_hpet = (struct hpet *)hdp->hd_address;
 
 	hpetp->hp_ntimer = hdp->hd_nirqs;
 
@@ -912,28 +918,32 @@ hpet_alloc (struct hpet_data *hdp)
 
 	hpet = hpetp->hp_hpet;
 
-	cap = hpet->hpet_cap;
+	cap = readq(&hpet->hpet_cap);
 
 	ntimer = ((cap & HPET_NUM_TIM_CAP_MASK) >> HPET_NUM_TIM_CAP_SHIFT) + 1;
 
-	if (!ntimer) {
-		printk(KERN_WARNING "hpet: no timers in config data\n");
-		return -ENODEV;
-	}
-	else if (hpetp->hp_ntimer != ntimer) {
+	if (hpetp->hp_ntimer != ntimer) {
 		printk(KERN_WARNING "hpet: number irqs doesn't agree"
-			" with number of timers\n");
+		       " with number of timers\n");
+		kfree(hpetp);
 		return -ENODEV;
 	}
 
+	if (last)
+		last->hp_next = hpetp;
+	else
+		hpets = hpetp;
+
+	last = hpetp;
+
 	hpetp->hp_period = (cap & HPET_COUNTER_CLK_PERIOD_MASK) >>
-		HPET_COUNTER_CLK_PERIOD_SHIFT;
+	    HPET_COUNTER_CLK_PERIOD_SHIFT;
 
-	mcfg = hpet->hpet_config;
+	mcfg = readq(&hpet->hpet_config);
 	if ((mcfg & HPET_ENABLE_CNF_MASK) == 0) {
-		hpet->hpet_mc = 0L;
+		write_counter(0L, &hpet->hpet_mc);
 		mcfg |= HPET_ENABLE_CNF_MASK;
-		hpet->hpet_config = mcfg;
+		writeq(mcfg, &hpet->hpet_config);
 	}
 
 	/*
@@ -944,12 +954,13 @@ hpet_alloc (struct hpet_data *hdp)
 	if (hdp->hd_flags ^ HPET_DATA_PLATFORM)
 		hpet_init_chrdev();
 
-	for (i = 0, devp = hpetp->hp_dev;  i < hpetp->hp_ntimer; i++, hpet_ntimer++, devp++) {
+	for (i = 0, devp = hpetp->hp_dev; i < hpetp->hp_ntimer;
+	     i++, hpet_ntimer++, devp++) {
 		unsigned long v;
-		volatile struct hpet_timer *timer;
+		struct hpet_timer *timer;
 
 		timer = &hpet->hpet_timers[devp - hpetp->hp_dev];
-		v = timer->hpet_config;
+		v = readq(&timer->hpet_config);
 
 		devp->hd_hpets = hpetp;
 		devp->hd_hpet = hpet;
@@ -957,6 +968,10 @@ hpet_alloc (struct hpet_data *hdp)
 
 		devp->hd_minor = hpet_ntimer;
 
+		/*
+		 * If the timer was reserved by platform code,
+		 * then make timer unavailable for opens.
+		 */
 		if (hdp->hd_state & (1 << i)) {
 			devp->hd_flags = HPET_OPEN;
 			continue;
@@ -967,7 +982,7 @@ hpet_alloc (struct hpet_data *hdp)
 
 		sprintf(&hpetname[5], "%d", hpet_ntimer);
 		devfs_mk_cdev(MKDEV(HPET_MAJOR, hpet_ntimer),
-			S_IFCHR|S_IRUSR|S_IWUSR, hpetname);
+			      S_IFCHR | S_IRUSR | S_IWUSR, hpetname);
 		init_waitqueue_head(&devp->hd_waitqueue);
 	}
 
@@ -976,8 +991,7 @@ hpet_alloc (struct hpet_data *hdp)
 	return 0;
 }
 
-static acpi_status __init
-hpet_resources (struct acpi_resource *res, void *data)
+static acpi_status __init hpet_resources(struct acpi_resource *res, void *data)
 {
 	struct hpet_data *hdp;
 	acpi_status status;
@@ -992,13 +1006,13 @@ hpet_resources (struct acpi_resource *re
 		unsigned long size;
 
 		size = addr.max_address_range - addr.min_address_range + 1;
-		hdp->hd_address = (unsigned long) ioremap(addr.min_address_range, size);
+		hdp->hd_address =
+		    (unsigned long)ioremap(addr.min_address_range, size);
 
 		for (hpetp = hpets; hpetp; hpetp = hpetp->hp_next)
-			if (hpetp->hp_hpet == (struct hpet *) (hdp->hd_address))
+			if (hpetp->hp_hpet == (struct hpet *)(hdp->hd_address))
 				return -EBUSY;
-	}
-	else if (res->id == ACPI_RSTYPE_EXT_IRQ) {
+	} else if (res->id == ACPI_RSTYPE_EXT_IRQ) {
 		struct acpi_resource_ext_irq *irqp;
 		int i;
 
@@ -1009,8 +1023,10 @@ hpet_resources (struct acpi_resource *re
 
 			for (i = 0; i < hdp->hd_nirqs; i++)
 #ifdef	CONFIG_IA64
-				hdp->hd_irq[i] = acpi_register_irq(irqp->interrupts[i],
-							irqp->active_high_low, irqp->edge_level);
+				hdp->hd_irq[i] =
+				    acpi_register_irq(irqp->interrupts[i],
+						      irqp->active_high_low,
+						      irqp->edge_level);
 #else
 				hdp->hd_irq[i] = irqp->interrupts[i];
 #endif
@@ -1020,15 +1036,16 @@ hpet_resources (struct acpi_resource *re
 	return AE_OK;
 }
 
-static int __init
-hpet_acpi_add (struct acpi_device *device)
+static int __init hpet_acpi_add(struct acpi_device *device)
 {
 	acpi_status result;
 	struct hpet_data data;
 
 	memset(&data, 0, sizeof(data));
 
-	result = acpi_walk_resources(device->handle, METHOD_NAME__CRS, hpet_resources, &data);
+	result =
+	    acpi_walk_resources(device->handle, METHOD_NAME__CRS,
+				hpet_resources, &data);
 
 	if (ACPI_FAILURE(result))
 		return -ENODEV;
@@ -1041,33 +1058,34 @@ hpet_acpi_add (struct acpi_device *devic
 	return hpet_alloc(&data);
 }
 
-static int __init
-hpet_acpi_remove (struct acpi_device *device, int type)
+static int __init hpet_acpi_remove(struct acpi_device *device, int type)
 {
 	return 0;
 }
 
 static struct acpi_driver hpet_acpi_driver __initdata = {
-	.name	=	"hpet",
-	.class	=	"",
-	.ids	=	"PNP0103",
+	.name = "hpet",
+	.class = "",
+	.ids = "PNP0103",
 	.ops = {
-		.add	=	hpet_acpi_add,
-		.remove	=	hpet_acpi_remove,
-	},
+		.add = hpet_acpi_add,
+		.remove = hpet_acpi_remove,
+		},
 };
 
-
-
-static int __init
-hpet_init (void)
+static int __init hpet_init(void)
 {
 	struct proc_dir_entry *entry;
 
+	/*
+	 * If platform dependent code allocated hpet,
+	 * then do the rest of post boot initialization
+	 * of these hpets.
+	 */
 	if (hpets)
 		hpet_post_platform();
 
-	(void) acpi_bus_register_driver(&hpet_acpi_driver);
+	(void)acpi_bus_register_driver(&hpet_acpi_driver);
 
 	if (hpets) {
 		entry = create_proc_entry("driver/hpet", 0, 0);
@@ -1079,25 +1097,23 @@ hpet_init (void)
 
 #ifdef	CONFIG_TIME_INTERPOLATION
 		{
-			volatile struct hpet	*hpet;
+			struct hpet *hpet;
 
 			hpet = hpets->hp_hpet;
 			hpet_cycles_per_sec = hpet_time_div(hpets->hp_period);
 			hpet_interpolator.frequency = hpet_cycles_per_sec;
 			hpet_interpolator.drift = hpet_cycles_per_sec *
-				HPET_DRIFT / 1000000;
+			    HPET_DRIFT / 1000000;
 			hpet_nsecs_per_cycle = 1000000000 / hpet_cycles_per_sec;
 			register_time_interpolator(&hpet_interpolator);
 		}
 #endif
 		return 0;
-	}
-	else
+	} else
 		return -ENODEV;
 }
 
-static void __exit
-hpet_exit (void)
+static void __exit hpet_exit(void)
 {
 	acpi_bus_unregister_driver(&hpet_acpi_driver);
 
@@ -1109,7 +1125,6 @@ hpet_exit (void)
 	return;
 }
 
-
 module_init(hpet_init);
 module_exit(hpet_exit);
 MODULE_AUTHOR("Bob Picco <Robert.Picco@hp.com>");
diff -puN drivers/char/Kconfig~hpet-driver-updates drivers/char/Kconfig
--- 25/drivers/char/Kconfig~hpet-driver-updates	Mon May 17 15:59:44 2004
+++ 25-akpm/drivers/char/Kconfig	Mon May 17 15:59:44 2004
@@ -958,15 +958,16 @@ config RAW_DRIVER
           with the O_DIRECT flag.
 
 config HPET
-	bool "HPET - High Precision Event Timer"
+	bool "HPET - High Precision Event Timer" if (X86 || IA64)
 	default n
+	depends on ACPI
 	help
 	  If you say Y here, you will have a device named "/dev/hpet/XX" for
 	  each timer supported by the HPET.  The timers are
 	  non-periodioc and/or periodic.
 
 config HPET_RTC_IRQ
-	bool "HPET Control RTC IRQ"
+	bool "HPET Control RTC IRQ" if !HPET_EMULATE_RTC
 	default n
 	depends on HPET
 	help
diff -puN include/linux/hpet.h~hpet-driver-updates include/linux/hpet.h
--- 25/include/linux/hpet.h~hpet-driver-updates	Mon May 17 15:59:44 2004
+++ 25-akpm/include/linux/hpet.h	Mon May 17 15:59:44 2004
@@ -6,26 +6,26 @@
  */
 
 struct hpet {
-	u64	hpet_cap;		/* capabilities */
-	u64	res0;			/* reserved */
-	u64	hpet_config;		/* configuration */
-	u64	res1;			/* reserved */
-	u64	hpet_isr;		/* interrupt status reg */
-	u64	res2[25];		/* reserved */
-	union {				/* main counter */
-		u64		_hpet_mc64;
-		u32		_hpet_mc32;
-		unsigned long 	_hpet_mc;
+	u64 hpet_cap;		/* capabilities */
+	u64 res0;		/* reserved */
+	u64 hpet_config;	/* configuration */
+	u64 res1;		/* reserved */
+	u64 hpet_isr;		/* interrupt status reg */
+	u64 res2[25];		/* reserved */
+	union {			/* main counter */
+		u64 _hpet_mc64;
+		u32 _hpet_mc32;
+		unsigned long _hpet_mc;
 	} _u0;
-	u64	res3;			/* reserved */
+	u64 res3;		/* reserved */
 	struct hpet_timer {
-		u64	hpet_config;	/* configuration/cap */
-		union {			/* timer compare register */
-			u64		_hpet_hc64;
-			u32		_hpet_hc32;
-			unsigned long	_hpet_compare;
+		u64 hpet_config;	/* configuration/cap */
+		union {		/* timer compare register */
+			u64 _hpet_hc64;
+			u32 _hpet_hc32;
+			unsigned long _hpet_compare;
 		} _u1;
-		u64	hpet_fsb[2];	/* FSB route */
+		u64 hpet_fsb[2];	/* FSB route */
 	} hpet_timers[1];
 };
 
@@ -47,12 +47,10 @@ struct hpet {
 #define	HPET_NUM_TIM_CAP_MASK		(0x1f00)
 #define	HPET_NUM_TIM_CAP_SHIFT		(8ULL)
 
-
 /*
  * HPET general configuration register
  */
 
-
 #define	HPET_LEG_RT_CNF_MASK		(2UL)
 #define	HPET_ENABLE_CNF_MASK		(1UL)
 
@@ -63,9 +61,6 @@ struct hpet {
 #define	HPET_ISR_CLEAR(HPET, TIMER)				\
 		(HPET)->hpet_isr |= (1UL << TIMER)
 
-
-
-
 /*
  * Timer configuration register
  */
@@ -95,38 +90,35 @@ struct hpet {
 #define	Tn_FSB_INT_VAL_MASK		(0x00000000ffffffffULL)
 
 struct hpet_info {
-		unsigned long 	hi_ireqfreq;	/* Hz */
-		unsigned long	hi_flags;	/* information */
+	unsigned long hi_ireqfreq;	/* Hz */
+	unsigned long hi_flags;	/* information */
 };
 
-#define	HPET_INFO_PERIODIC	0x0001		/* timer is periodic */
+#define	HPET_INFO_PERIODIC	0x0001	/* timer is periodic */
 
-
-#define	HPET_IE_ON	_IO('h', 0x01)			/* interrupt on */
-#define	HPET_IE_OFF	_IO('h', 0x02)			/* interrupt off */
+#define	HPET_IE_ON	_IO('h', 0x01)	/* interrupt on */
+#define	HPET_IE_OFF	_IO('h', 0x02)	/* interrupt off */
 #define	HPET_INFO	_IOR('h', 0x03, struct hpet_info)
-#define	HPET_EPI	_IO('h', 0x04)			/* enable periodic */
-#define	HPET_DPI	_IO('h', 0x05)			/* disable periodic */
+#define	HPET_EPI	_IO('h', 0x04)	/* enable periodic */
+#define	HPET_DPI	_IO('h', 0x05)	/* disable periodic */
 #define	HPET_IRQFREQ	_IOW('h', 0x6, unsigned long)	/* IRQFREQ usec */
 
-
-
 /*
  * exported interfaces
  */
 
 struct hpet_task {
-	void	(*ht_func)(void *);
-	void	*ht_data;
-	void	*ht_opaque;
+	void (*ht_func) (void *);
+	void *ht_data;
+	void *ht_opaque;
 };
 
 struct hpet_data {
-	unsigned long	hd_address;
-	unsigned short	hd_nirqs;
-	unsigned short	hd_flags;
-	unsigned int	hd_state;	/* timer allocated */
-	unsigned int	hd_irq[HPET_MAX_TIMERS];
+	unsigned long hd_address;
+	unsigned short hd_nirqs;
+	unsigned short hd_flags;
+	unsigned int hd_state;	/* timer allocated */
+	unsigned int hd_irq[HPET_MAX_TIMERS];
 };
 
 #define	HPET_DATA_PLATFORM	0x0001	/* platform call to hpet_alloc */
@@ -136,5 +128,4 @@ int hpet_register(struct hpet_task *, in
 int hpet_unregister(struct hpet_task *);
 int hpet_control(struct hpet_task *, unsigned int, unsigned long);
 
-
-#endif	/* !__HPET__ */
+#endif				/* !__HPET__ */

_
