/*
   * linux/drivers/parisc/power.c
   * HP PARISC soft power switch support driver
   *
   * Copyright (c) 2001-2007 Helge Deller <deller@gmx.de>
   * All rights reserved.
   *
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions, and the following disclaimer,
   *    without modification.
   * 2. The name of the author may not be used to endorse or promote products
   *    derived from this software without specific prior written permission.
   *
   * Alternatively, this software may be distributed under the terms of the
   * GNU General Public License ("GPL").
   *
   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
   * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   *
   *
   *  HINT:
   *  Support of the soft power switch button may be enabled or disabled at
   *  runtime through the "/proc/sys/kernel/power" procfs entry.
   */ 
  
  #include <linux/module.h>
  #include <linux/init.h>
  #include <linux/kernel.h>
  #include <linux/notifier.h>
  #include <linux/reboot.h>
  #include <linux/sched.h>
  #include <linux/kthread.h>
  #include <linux/pm.h>
  
  #include <asm/pdc.h>
  #include <asm/io.h>
  #include <asm/led.h>
  
  #define DRIVER_NAME  "powersw"
  #define KTHREAD_NAME "kpowerswd"
  
  /* how often should the power button be polled ? */
  #define POWERSWITCH_POLL_PER_SEC 2
  
  /* how long does the power button needs to be down until we react ? */
  #define POWERSWITCH_DOWN_SEC 2
  
  /* assembly code to access special registers */
  /* taken from PCXL ERS page 82 */
  #define DIAG_CODE(code)		(0x14000000 + ((code)<<5))
  
  #define MFCPU_X(rDiagReg, t_ch, t_th, code) \
  	(DIAG_CODE(code) + ((rDiagReg)<<21) + ((t_ch)<<16) + ((t_th)<<0) )
  	
  #define MTCPU(dr, gr)		MFCPU_X(dr, gr,  0, 0x12)       /* move value of gr to dr[dr] */
  #define MFCPU_C(dr, gr)		MFCPU_X(dr, gr,  0, 0x30)	/* for dr0 and dr8 only ! */
  #define MFCPU_T(dr, gr)		MFCPU_X(dr,  0, gr, 0xa0)	/* all dr except dr0 and dr8 */
  	
  #define __getDIAG(dr) ( { 			\
          register unsigned long __res asm("r28");\
  	 __asm__ __volatile__ (			\
  		".word %1" : "=&r" (__res) : "i" (MFCPU_T(dr,28) ) \
  	);					\
  	__res;					\
  } )
  
  /* local shutdown counter */
  static int shutdown_timer __read_mostly;
  
  /* check, give feedback and start shutdown after one second */
  static void process_shutdown(void)
  {
  	if (shutdown_timer == 0)
  		printk(KERN_ALERT KTHREAD_NAME ": Shutdown requested...
  ");
  
  	shutdown_timer++;
  	
  	/* wait until the button was pressed for 1 second */
  	if (shutdown_timer == (POWERSWITCH_DOWN_SEC*POWERSWITCH_POLL_PER_SEC)) {
  		static const char msg[] = "Shutting down...";
  		printk(KERN_INFO KTHREAD_NAME ": %s
  ", msg);
  		lcd_print(msg);
  
  		/* send kill signal */
  		if (kill_cad_pid(SIGINT, 1)) {
  			/* just in case killing init process failed */
  			if (pm_power_off)
  				pm_power_off();
  		}
  	}
  }
  
  
  /* main power switch task struct */
  static struct task_struct *power_task;
  
  /* filename in /proc which can be used to enable/disable the power switch */
  #define SYSCTL_FILENAME	"sys/kernel/power"
  
  /* soft power switch enabled/disabled */
  int pwrsw_enabled __read_mostly = 1;
  
  /* main kernel thread worker. It polls the button state */
  static int kpowerswd(void *param)
  {
  	__set_current_state(TASK_RUNNING);
  
  	do {
  		int button_not_pressed;
  		unsigned long soft_power_reg = (unsigned long) param;
  
  		schedule_timeout_interruptible(pwrsw_enabled ? HZ : HZ/POWERSWITCH_POLL_PER_SEC);
  		__set_current_state(TASK_RUNNING);
  
  		if (unlikely(!pwrsw_enabled))
  			continue;
  
  		if (soft_power_reg) {
  			/*
  			 * Non-Gecko-style machines:
  			 * Check the power switch status which is read from the
  			 * real I/O location at soft_power_reg.
  			 * Bit 31 ("the lowest bit) is the status of the power switch.
  			 * This bit is "1" if the button is NOT pressed.
  			 */
  			button_not_pressed = (gsc_readl(soft_power_reg) & 0x1);
  		} else {
  			/*
  			 * On gecko style machines (e.g. 712/xx and 715/xx) 
  			 * the power switch status is stored in Bit 0 ("the highest bit")
  			 * of CPU diagnose register 25.
  			 * Warning: Some machines never reset the DIAG flag, even if
  			 * the button has been released again.
  			 */
  			button_not_pressed = (__getDIAG(25) & 0x80000000);
  		}
  
  		if (likely(button_not_pressed)) {
  			if (unlikely(shutdown_timer && /* avoid writing if not necessary */
  				shutdown_timer < (POWERSWITCH_DOWN_SEC*POWERSWITCH_POLL_PER_SEC))) {
  				shutdown_timer = 0;
  				printk(KERN_INFO KTHREAD_NAME ": Shutdown request aborted.
  ");
  			}
  		} else
  			process_shutdown();
  
  
  	} while (!kthread_should_stop());
  
  	return 0;
  }
  
  
  /*
   * powerfail interruption handler (irq IRQ_FROM_REGION(CPU_IRQ_REGION)+2) 
   */
  #if 0
  static void powerfail_interrupt(int code, void *x)
  {
  	printk(KERN_CRIT "POWERFAIL INTERRUPTION !
  ");
  	poweroff();
  }
  #endif
  
  
  
  
  /* parisc_panic_event() is called by the panic handler.
   * As soon as a panic occurs, our tasklets above will not be
   * executed any longer. This function then re-enables the 
   * soft-power switch and allows the user to switch off the system
   */
  static int parisc_panic_event(struct notifier_block *this,
  		unsigned long event, void *ptr)
  {
  	/* re-enable the soft-power switch */
  	pdc_soft_power_button(0);
  	return NOTIFY_DONE;
  }
  
  static struct notifier_block parisc_panic_block = {
  	.notifier_call	= parisc_panic_event,
  	.priority	= INT_MAX,
  };
  
  
  static int __init power_init(void)
  {
  	unsigned long ret;
  	unsigned long soft_power_reg;
  
  #if 0
  	request_irq( IRQ_FROM_REGION(CPU_IRQ_REGION)+2, &powerfail_interrupt,
  		0, "powerfail", NULL);
  #endif
  
  	/* enable the soft power switch if possible */
  	ret = pdc_soft_power_info(&soft_power_reg);
  	if (ret == PDC_OK)
  		ret = pdc_soft_power_button(1);
  	if (ret != PDC_OK)
  		soft_power_reg = -1UL;
  	
  	switch (soft_power_reg) {
  	case 0:		printk(KERN_INFO DRIVER_NAME ": Gecko-style soft power switch enabled.
  ");
  			break;
  			
  	case -1UL:	printk(KERN_INFO DRIVER_NAME ": Soft power switch support not available.
  ");
  			return -ENODEV;
  	
  	default:	printk(KERN_INFO DRIVER_NAME ": Soft power switch at 0x%08lx enabled.
  ",
  				soft_power_reg);
  	}
  
  	power_task = kthread_run(kpowerswd, (void*)soft_power_reg, KTHREAD_NAME);
  	if (IS_ERR(power_task)) {
  		printk(KERN_ERR DRIVER_NAME ": thread creation failed.  Driver not loaded.
  ");
  		pdc_soft_power_button(0);
  		return -EIO;
  	}
  
  	/* Register a call for panic conditions. */
  	atomic_notifier_chain_register(&panic_notifier_list,
  			&parisc_panic_block);
  
  	return 0;
  }
  
  static void __exit power_exit(void)
  {
  	kthread_stop(power_task);
  
  	atomic_notifier_chain_unregister(&panic_notifier_list,
  			&parisc_panic_block);
  
  	pdc_soft_power_button(0);
  }
  
  arch_initcall(power_init);
  module_exit(power_exit);
  
  
  MODULE_AUTHOR("Helge Deller <deller@gmx.de>");
  MODULE_DESCRIPTION("Soft power switch driver");
  MODULE_LICENSE("Dual BSD/GPL");