static int simeth_tx(struct sk_buff *skb, struct net_device *dev);
 static int simeth_rx(struct net_device *dev);
 static struct net_device_stats *simeth_get_stats(struct net_device *dev);
-static irqreturn_t simeth_interrupt(int irq, void *dev_id, struct pt_regs * regs);
+static irqreturn_t simeth_interrupt(int irq, void *dev_id);
 static void set_multicast_list(struct net_device *dev);
 static int simeth_device_event(struct notifier_block *this,unsigned long event, void *ptr);
 
  * Interrupt handler (Yes, we can do it too !!!)
  */
 static irqreturn_t
-simeth_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+simeth_interrupt(int irq, void *dev_id)
 {
        struct net_device *dev = dev_id;
 
 
 #endif
 }
 
-static  void receive_chars(struct tty_struct *tty, struct pt_regs *regs)
+static  void receive_chars(struct tty_struct *tty)
 {
        unsigned char ch;
        static unsigned char seen_esc = 0;
                                                ch = ia64_ssc(0, 0, 0, 0,
                                                              SSC_GETCHAR);
                                        while (!ch);
-                                       handle_sysrq(ch, regs, NULL);
+                                       handle_sysrq(ch, NULL);
                                }
 #endif
                                seen_esc = 0;
 /*
  * This is the serial driver's interrupt routine for a single port
  */
-static irqreturn_t rs_interrupt_single(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t rs_interrupt_single(int irq, void *dev_id)
 {
        struct async_struct * info;
 
         * pretty simple in our case, because we only get interrupts
         * on inbound traffic
         */
-       receive_chars(info->tty, regs);
+       receive_chars(info->tty);
        return IRQ_HANDLED;
 }
 
 {
        unsigned long flags;
        int     retval=0;
-       irqreturn_t (*handler)(int, void *, struct pt_regs *);
+       irqreturn_t (*handler)(int, void *);
        struct serial_state *state= info->state;
        unsigned long page;
 
 
  * Notify the heartbeat check thread that an IRQ has been received.
  */
 static irqreturn_t
-xpc_act_IRQ_handler(int irq, void *dev_id, struct pt_regs *regs)
+xpc_act_IRQ_handler(int irq, void *dev_id)
 {
        atomic_inc(&xpc_act_IRQ_rcvd);
        wake_up_interruptible(&xpc_act_IRQ_wq);
  *     irq - Interrupt ReQuest number. NOT USED.
  *
  *     dev_id - partid of IPI's potential sender.
- *
- *     regs - processor's context before the processor entered
- *            interrupt code. NOT USED.
  */
 irqreturn_t
-xpc_notify_IRQ_handler(int irq, void *dev_id, struct pt_regs *regs)
+xpc_notify_IRQ_handler(int irq, void *dev_id)
 {
        partid_t partid = (partid_t) (u64) dev_id;
        struct xpc_partition *part = &xpc_partitions[partid];
 
 extern struct device *xpc_chan;
 extern int xpc_disengage_request_timelimit;
 extern int xpc_disengage_request_timedout;
-extern irqreturn_t xpc_notify_IRQ_handler(int, void *, struct pt_regs *);
+extern irqreturn_t xpc_notify_IRQ_handler(int, void *);
 extern void xpc_dropped_IPI_check(struct xpc_partition *);
 extern void xpc_activate_partition(struct xpc_partition *);
 extern void xpc_activate_kthreads(struct xpc_channel *, int);