Viewing file:  h8.c (31.09 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* Hitachi H8/337 Microcontroller driver
*
* The H8 is used to deal with the power and thermal environment
* of a system.
*
* Fixes:
* June 1999, AV added releasing /proc/driver/h8
* Feb 2000, Borislav Deianov
* changed queues to use list.h instead of lists.h
*/
#include <linux/config.h>
#include <linux/module.h>
#include <asm/system.h>
#include <asm/segment.h>
#include <asm/io.h>
#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/timer.h>
#include <linux/fcntl.h>
#include <linux/linkage.h>
#include <linux/stat.h>
#include <linux/proc_fs.h>
#include <linux/miscdevice.h>
#include <linux/list.h>
#include <linux/ioport.h>
#include <linux/poll.h>
#include <linux/init.h>
#include <linux/slab.h>
#define __KERNEL_SYSCALLS__
#include <asm/unistd.h>
#include "h8.h"
#define DEBUG_H8
#ifdef DEBUG_H8
#define Dprintk printk
#else
#define Dprintk
#endif
#define XDprintk if(h8_debug==-1)printk
/*
* The h8 device is one of the misc char devices.
*/
#define H8_MINOR_DEV 140
/*
* Forward declarations.
*/
static int h8_init(void);
static int h8_display_blank(void);
static int h8_display_unblank(void);
static void h8_intr(int irq, void *dev_id, struct pt_regs *regs);
static int h8_get_info(char *, char **, off_t, int);
/*
* Support Routines.
*/
static void h8_hw_init(void);
static void h8_start_new_cmd(void);
static void h8_send_next_cmd_byte(void);
static void h8_read_event_status(void);
static void h8_sync(void);
static void h8_q_cmd(u_char *, int, int);
static void h8_cmd_done(h8_cmd_q_t *qp);
static int h8_alloc_queues(void);
static u_long h8_get_cpu_speed(void);
static int h8_get_curr_temp(u_char curr_temp[]);
static void h8_get_max_temp(void);
static void h8_get_upper_therm_thold(void);
static void h8_set_upper_therm_thold(int);
static int h8_get_ext_status(u_char stat_word[]);
static int h8_monitor_thread(void *);
static int h8_manage_therm(void);
static void h8_set_cpu_speed(int speed_divisor);
static void h8_start_monitor_timer(unsigned long secs);
static void h8_activate_monitor(unsigned long unused);
/* in arch/alpha/kernel/lca.c */
extern void lca_clock_print(void);
extern int lca_get_clock(void);
extern void lca_clock_fiddle(int);
static void h8_set_event_mask(int);
static void h8_clear_event_mask(int);
/*
* Driver structures
*/
static struct timer_list h8_monitor_timer;
static int h8_monitor_timer_active = 0;
static char driver_version[] = "X0.0";/* no spaces */
static union intr_buf intrbuf;
static int intr_buf_ptr;
static union intr_buf xx;
static u_char last_temp;
/*
* I/O Macros for register reads and writes.
*/
#define H8_READ(a) inb((a))
#define H8_WRITE(d,a) outb((d),(a))
#define H8_GET_STATUS H8_READ((h8_base) + H8_STATUS_REG_OFF)
#define H8_READ_DATA H8_READ((h8_base) + H8_DATA_REG_OFF)
#define WRITE_DATA(d) H8_WRITE((d), h8_base + H8_DATA_REG_OFF)
#define WRITE_CMD(d) H8_WRITE((d), h8_base + H8_CMD_REG_OFF)
static unsigned int h8_base = H8_BASE_ADDR;
static unsigned int h8_irq = H8_IRQ;
static unsigned int h8_state = H8_IDLE;
static unsigned int h8_index = -1;
static unsigned int h8_enabled = 0;
static LIST_HEAD(h8_actq);
static LIST_HEAD(h8_cmdq);
static LIST_HEAD(h8_freeq);
/*
* Globals used in thermal control of Alphabook1.
*/
static int cpu_speed_divisor = -1;
static int h8_event_mask = 0;
static DECLARE_WAIT_QUEUE_HEAD(h8_monitor_wait);
static unsigned int h8_command_mask = 0;
static int h8_uthermal_threshold = DEFAULT_UTHERMAL_THRESHOLD;
static int h8_uthermal_window = UTH_HYSTERESIS;
static int h8_debug = 0xfffffdfc;
static int h8_ldamp = MHZ_115;
static int h8_udamp = MHZ_57;
static u_char h8_current_temp = 0;
static u_char h8_system_temp = 0;
static int h8_sync_channel = 0;
static DECLARE_WAIT_QUEUE_HEAD(h8_sync_wait);
static int h8_init_performed;
/* CPU speeds and clock divisor values */
static int speed_tab[6] = {230, 153, 115, 57, 28, 14};
/*
* H8 interrupt handler
*/
static void h8_intr(int irq, void *dev_id, struct pt_regs *regs)
{
u_char stat_reg, data_reg;
h8_cmd_q_t *qp = list_entry(h8_actq.next, h8_cmd_q_t, link);
stat_reg = H8_GET_STATUS;
data_reg = H8_READ_DATA;
XDprintk("h8_intr: state %d status 0x%x data 0x%x\n", h8_state, stat_reg, data_reg);
switch (h8_state) {
/* Response to an asynchronous event. */
case H8_IDLE: { /* H8_IDLE */
if (stat_reg & H8_OFULL) {
if (data_reg == H8_INTR) {
h8_state = H8_INTR_MODE;
/* Executing a command to determine what happened. */
WRITE_CMD(H8_RD_EVENT_STATUS);
intr_buf_ptr = 1;
WRITE_CMD(H8_RD_EVENT_STATUS);
} else {
Dprintk("h8_intr: idle stat 0x%x data 0x%x\n",
stat_reg, data_reg);
}
} else {
Dprintk("h8_intr: bogus interrupt\n");
}
break;
}
case H8_INTR_MODE: { /* H8_INTR_MODE */
XDprintk("H8 intr/intr_mode\n");
if (data_reg == H8_BYTE_LEVEL_ACK) {
return;
} else if (data_reg == H8_CMD_ACK) {
return;
} else {
intrbuf.byte[intr_buf_ptr] = data_reg;
if(!intr_buf_ptr) {
h8_state = H8_IDLE;
h8_read_event_status();
}
intr_buf_ptr--;
}
break;
}
/* Placed in this state by h8_start_new_cmd(). */
case H8_XMIT: { /* H8_XMIT */
XDprintk("H8 intr/xmit\n");
/* If a byte level acknowledgement has been received */
if (data_reg == H8_BYTE_LEVEL_ACK) {
XDprintk("H8 intr/xmit BYTE ACK\n");
qp->nacks++;
if (qp->nacks > qp->ncmd)
if(h8_debug & 0x1)
Dprintk("h8intr: bogus # of acks!\n");
/*
* If the number of bytes sent is less than the total
* number of bytes in the command.
*/
if (qp->cnt < qp->ncmd) {
h8_send_next_cmd_byte();
}
return;
/* If the complete command has produced an acknowledgement. */
} else if (data_reg == H8_CMD_ACK) {
XDprintk("H8 intr/xmit CMD ACK\n");
/* If there are response bytes */
if (qp->nrsp)
h8_state = H8_RCV;
else
h8_state = H8_IDLE;
qp->cnt = 0;
return;
/* Error, need to start over with a clean slate. */
} else if (data_reg == H8_NACK) {
XDprintk("h8_intr: NACK received restarting command\n");
qp->nacks = 0;
qp->cnt = 0;
h8_state = H8_IDLE;
WRITE_CMD(H8_SYNC);
return;
} else {
Dprintk ("h8intr: xmit unknown data 0x%x \n", data_reg);
return;
}
break;
}
case H8_RESYNC: { /* H8_RESYNC */
XDprintk("H8 intr/resync\n");
if (data_reg == H8_BYTE_LEVEL_ACK) {
return;
} else if (data_reg == H8_SYNC_BYTE) {
h8_state = H8_IDLE;
if (!list_empty(&h8_actq))
h8_send_next_cmd_byte();
} else {
Dprintk ("h8_intr: resync unknown data 0x%x \n", data_reg);
return;
}
break;
}
case H8_RCV: { /* H8_RCV */
XDprintk("H8 intr/rcv\n");
if (qp->cnt < qp->nrsp) {
qp->rcvbuf[qp->cnt] = data_reg;
qp->cnt++;
/* If command reception finished. */
if (qp->cnt == qp->nrsp) {
h8_state = H8_IDLE;
list_del(&qp->link);
h8_cmd_done (qp);
/* More commands to send over? */
if (!list_empty(&h8_cmdq))
h8_start_new_cmd();
}
return;
} else {
Dprintk ("h8intr: rcv overflow cmd 0x%x\n", qp->cmdbuf[0]);
}
break;
}
default: /* default */
Dprintk("H8 intr/unknown\n");
break;
}
return;
}
static void __exit h8_cleanup (void)
{
remove_proc_entry("driver/h8", NULL);
release_region(h8_base, 8);
free_irq(h8_irq, NULL);
}
static int __init h8_init(void)
{
if(request_irq(h8_irq, h8_intr, SA_INTERRUPT, "h8", NULL))
{
printk(KERN_ERR "H8: error: IRQ %d is not free\n", h8_irq);
return -EIO;
}
printk(KERN_INFO "H8 at 0x%x IRQ %d\n", h8_base, h8_irq);
create_proc_info_entry("driver/h8", 0, NULL, h8_get_info);
request_region(h8_base, 8, "h8");
h8_alloc_queues();
h8_hw_init();
kernel_thread(h8_monitor_thread, NULL, 0);
return 0;
}
module_init(h8_init);
module_exit(h8_cleanup);
static void __init h8_hw_init(void)
{
u_char buf[H8_MAX_CMD_SIZE];
/* set CPU speed to max for booting */
h8_set_cpu_speed(MHZ_230);
/*
* Initialize the H8
*/
h8_sync(); /* activate interrupts */
/* To clear conditions left by console */
h8_read_event_status();
/* Perform a conditioning read */
buf[0] = H8_DEVICE_CONTROL;
buf[1] = 0xff;
buf[2] = 0x0;
h8_q_cmd(buf, 3, 1);
/* Turn on built-in and external mice, capture power switch */
buf[0] = H8_DEVICE_CONTROL;
buf[1] = 0x0;
buf[2] = H8_ENAB_INT_PTR | H8_ENAB_EXT_PTR |
/*H8_DISAB_PWR_OFF_SW |*/ H8_ENAB_LOW_SPD_IND;
h8_q_cmd(buf, 3, 1);
h8_enabled = 1;
return;
}
static int h8_get_info(char *buf, char **start, off_t fpos, int length)
{
#ifdef CONFIG_PROC_FS
char *p;
if (!h8_enabled)
return 0;
p = buf;
/*
0) Linux driver version (this will change if format changes)
1)
2)
3)
4)
*/
p += sprintf(p, "%s \n",
driver_version
);
return p - buf;
#else
return 0;
#endif
}
/* Called from console driver -- must make sure h8_enabled. */
static int h8_display_blank(void)
{
#ifdef CONFIG_H8_DISPLAY_BLANK
int error;
if (!h8_enabled)
return 0;
error = h8_set_display_power_state(H8_STATE_STANDBY);
if (error == H8_SUCCESS)
return 1;
h8_error("set display standby", error);
#endif
return 0;
}
/* Called from console driver -- must make sure h8_enabled. */
static int h8_display_unblank(void)
{
#ifdef CONFIG_H8_DISPLAY_BLANK
int error;
if (!h8_enabled)
return 0;
error = h8_set_display_power_state(H8_STATE_READY);
if (error == H8_SUCCESS)
return 1;
h8_error("set display ready", error);
#endif
return 0;
}
static int h8_alloc_queues(void)
{
h8_cmd_q_t *qp;
unsigned long flags;
int i;
qp = (h8_cmd_q_t *)kmalloc((sizeof (h8_cmd_q_t) * H8_Q_ALLOC_AMOUNT),
GFP_KERNEL);
if (!qp) {
printk(KERN_ERR "H8: could not allocate memory for command queue\n");
return(0);
}
/* add to the free queue */
save_flags(flags); cli();
for (i = 0; i < H8_Q_ALLOC_AMOUNT; i++) {
/* place each at front of freeq */
list_add(&qp[i].link, &h8_freeq);
}
restore_flags(flags);
return (1);
}
/*
* Basic means by which commands are sent to the H8.
*/
void
h8_q_cmd(u_char *cmd, int cmd_size, int resp_size)
{
h8_cmd_q_t *qp;
unsigned long flags;
int i;
/* get cmd buf */
save_flags(flags); cli();
while (list_empty(&h8_freeq)) {
Dprintk("H8: need to allocate more cmd buffers\n");
restore_flags(flags);
h8_alloc_queues();
save_flags(flags); cli();
}
/* get first element from queue */
qp = list_entry(h8_freeq.next, h8_cmd_q_t, link);
list_del(&qp->link);
restore_flags(flags);
/* fill it in */
for (i = 0; i < cmd_size; i++)
qp->cmdbuf[i] = cmd[i];
qp->ncmd = cmd_size;
qp->nrsp = resp_size;
/* queue it at the end of the cmd queue */
save_flags(flags); cli();
/* XXX this actually puts it at the start of cmd queue, bug? */
list_add(&qp->link, &h8_cmdq);
restore_flags(flags);
h8_start_new_cmd();
}
void
h8_start_new_cmd(void)
{
unsigned long flags;
h8_cmd_q_t *qp;
save_flags(flags); cli();
if (h8_state != H8_IDLE) {
if (h8_debug & 0x1)
Dprintk("h8_start_new_cmd: not idle\n");
restore_flags(flags);
return;
}
if (!list_empty(&h8_actq)) {
Dprintk("h8_start_new_cmd: inconsistency: IDLE with non-empty active queue!\n");
restore_flags(flags);
return;
}
if (list_empty(&h8_cmdq)) {
Dprintk("h8_start_new_cmd: no command to dequeue\n");
restore_flags(flags);
return;
}
/*
* Take first command off of the command queue and put
* it on the active queue.
*/
qp = list_entry(h8_cmdq.next, h8_cmd_q_t, link);
list_del(&qp->link);
/* XXX should this go to the end of the active queue? */
list_add(&qp->link, &h8_actq);
h8_state = H8_XMIT;
if (h8_debug & 0x1)
Dprintk("h8_start_new_cmd: Starting a command\n");
qp->cnt = 1;
WRITE_CMD(qp->cmdbuf[0]); /* Kick it off */
restore_flags(flags);
return;
}
void
h8_send_next_cmd_byte(void)
{
h8_cmd_q_t *qp = list_entry(h8_actq.next, h8_cmd_q_t, link);
int cnt;
cnt = qp->cnt;
qp->cnt++;
if (h8_debug & 0x1)
Dprintk("h8 sending next cmd byte 0x%x (0x%x)\n",
cnt, qp->cmdbuf[cnt]);
if (cnt) {
WRITE_DATA(qp->cmdbuf[cnt]);
} else {
WRITE_CMD(qp->cmdbuf[cnt]);
}
return;
}
/*
* Synchronize H8 communications channel for command transmission.
*/
void
h8_sync(void)
{
u_char buf[H8_MAX_CMD_SIZE];
buf[0] = H8_SYNC;
buf[1] = H8_SYNC_BYTE;
h8_q_cmd(buf, 2, 1);
}
/*
* Responds to external interrupt. Reads event status word and
* decodes type of interrupt.
*/
void
h8_read_event_status(void)
{
if(h8_debug & 0x200)
printk(KERN_DEBUG "h8_read_event_status: value 0x%x\n", intrbuf.word);
/*
* Power related items
*/
if (intrbuf.word & H8_DC_CHANGE) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: DC_CHANGE\n");
/* see if dc added or removed, set batt/dc flag, send event */
h8_set_event_mask(H8_MANAGE_BATTERY);
wake_up(&h8_monitor_wait);
}
if (intrbuf.word & H8_POWER_BUTTON) {
printk(KERN_CRIT "Power switch pressed - please wait - preparing to power
off\n");
h8_set_event_mask(H8_POWER_BUTTON);
wake_up(&h8_monitor_wait);
}
/*
* Thermal related items
*/
if (intrbuf.word & H8_THERMAL_THRESHOLD) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: THERMAL_THRESHOLD\n");
h8_set_event_mask(H8_MANAGE_UTHERM);
wake_up(&h8_monitor_wait);
}
/*
* nops -for now
*/
if (intrbuf.word & H8_DOCKING_STATION_STATUS) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: DOCKING_STATION_STATUS\n");
/* read_ext_status */
}
if (intrbuf.word & H8_EXT_BATT_STATUS) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: EXT_BATT_STATUS\n");
}
if (intrbuf.word & H8_EXT_BATT_CHARGE_STATE) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: EXT_BATT_CHARGE_STATE\n");
}
if (intrbuf.word & H8_BATT_CHANGE_OVER) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: BATT_CHANGE_OVER\n");
}
if (intrbuf.word & H8_WATCHDOG) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: WATCHDOG\n");
/* nop */
}
if (intrbuf.word & H8_SHUTDOWN) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: SHUTDOWN\n");
/* nop */
}
if (intrbuf.word & H8_KEYBOARD) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: KEYBOARD\n");
/* nop */
}
if (intrbuf.word & H8_EXT_MOUSE_OR_CASE_SWITCH) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: EXT_MOUSE_OR_CASE_SWITCH\n");
/* read_ext_status*/
}
if (intrbuf.word & H8_INT_BATT_LOW) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: INT_BATT_LOW\n"); post
/* event, warn user */
}
if (intrbuf.word & H8_INT_BATT_CHARGE_STATE) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: INT_BATT_CHARGE_STATE\n");
/* nop - happens often */
}
if (intrbuf.word & H8_INT_BATT_STATUS) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: INT_BATT_STATUS\n");
}
if (intrbuf.word & H8_INT_BATT_CHARGE_THRESHOLD) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: INT_BATT_CHARGE_THRESHOLD\n");
/* nop - happens often */
}
if (intrbuf.word & H8_EXT_BATT_LOW) {
if(h8_debug & 0x4)
printk(KERN_DEBUG "h8_read_event_status: EXT_BATT_LOW\n");
/*if no internal, post event, warn user */
/* else nop */
}
return;
}
/*
* Function called when H8 has performed requested command.
*/
static void
h8_cmd_done(h8_cmd_q_t *qp)
{
/* what to do */
switch (qp->cmdbuf[0]) {
case H8_SYNC:
if (h8_debug & 0x40000)
printk(KERN_DEBUG "H8: Sync command done - byte returned was 0x%x\n",
qp->rcvbuf[0]);
list_add(&qp->link, &h8_freeq);
break;
case H8_RD_SN:
case H8_RD_ENET_ADDR:
printk(KERN_DEBUG "H8: read Ethernet address: command done - address: %x - %x - %x - %x - %x - %x \n",
qp->rcvbuf[0], qp->rcvbuf[1], qp->rcvbuf[2],
qp->rcvbuf[3], qp->rcvbuf[4], qp->rcvbuf[5]);
list_add(&qp->link, &h8_freeq);
break;
case H8_RD_HW_VER:
case H8_RD_MIC_VER:
case H8_RD_MAX_TEMP:
printk(KERN_DEBUG "H8: Max recorded CPU temp %d, Sys temp %d\n",
qp->rcvbuf[0], qp->rcvbuf[1]);
list_add(&qp->link, &h8_freeq);
break;
case H8_RD_MIN_TEMP:
printk(KERN_DEBUG "H8: Min recorded CPU temp %d, Sys temp %d\n",
qp->rcvbuf[0], qp->rcvbuf[1]);
list_add(&qp->link, &h8_freeq);
break;
case H8_RD_CURR_TEMP:
h8_sync_channel |= H8_RD_CURR_TEMP;
xx.byte[0] = qp->rcvbuf[0];
xx.byte[1] = qp->rcvbuf[1];
wake_up(&h8_sync_wait);
list_add(&qp->link, &h8_freeq);
break;
case H8_RD_SYS_VARIENT:
case H8_RD_PWR_ON_CYCLES:
printk(KERN_DEBUG " H8: RD_PWR_ON_CYCLES command done\n");
break;
case H8_RD_PWR_ON_SECS:
printk(KERN_DEBUG "H8: RD_PWR_ON_SECS command done\n");
break;
case H8_RD_RESET_STATUS:
case H8_RD_PWR_DN_STATUS:
case H8_RD_EVENT_STATUS:
case H8_RD_ROM_CKSM:
case H8_RD_EXT_STATUS:
xx.byte[1] = qp->rcvbuf[0];
xx.byte[0] = qp->rcvbuf[1];
h8_sync_channel |= H8_GET_EXT_STATUS;
wake_up(&h8_sync_wait);
list_add(&qp->link, &h8_freeq);
break;
case H8_RD_USER_CFG:
case H8_RD_INT_BATT_VOLT:
case H8_RD_DC_INPUT_VOLT:
case H8_RD_HORIZ_PTR_VOLT:
case H8_RD_VERT_PTR_VOLT:
case H8_RD_EEPROM_STATUS:
case H8_RD_ERR_STATUS:
case H8_RD_NEW_BUSY_SPEED:
case H8_RD_CONFIG_INTERFACE:
case H8_RD_INT_BATT_STATUS:
printk(KERN_DEBUG "H8: Read int batt status cmd done - returned was %x %x %x\n",
qp->rcvbuf[0], qp->rcvbuf[1], qp->rcvbuf[2]);
list_add(&qp->link, &h8_freeq);
break;
case H8_RD_EXT_BATT_STATUS:
case H8_RD_PWR_UP_STATUS:
case H8_RD_EVENT_STATUS_MASK:
case H8_CTL_EMU_BITPORT:
case H8_DEVICE_CONTROL:
if(h8_debug & 0x20000) {
printk(KERN_DEBUG "H8: Device control cmd done - byte returned was 0x%x\n",
qp->rcvbuf[0]);
}
list_add(&qp->link, &h8_freeq);
break;
case H8_CTL_TFT_BRT_DC:
case H8_CTL_WATCHDOG:
case H8_CTL_MIC_PROT:
case H8_CTL_INT_BATT_CHG:
case H8_CTL_EXT_BATT_CHG:
case H8_CTL_MARK_SPACE:
case H8_CTL_MOUSE_SENSITIVITY:
case H8_CTL_DIAG_MODE:
case H8_CTL_IDLE_AND_BUSY_SPDS:
printk(KERN_DEBUG "H8: Idle and busy speed command done\n");
break;
case H8_CTL_TFT_BRT_BATT:
case H8_CTL_UPPER_TEMP:
if(h8_debug & 0x10) {
XDprintk("H8: ctl upper thermal thresh cmd done - returned was %d\n",
qp->rcvbuf[0]);
}
list_add(&qp->link, &h8_freeq);
break;
case H8_CTL_LOWER_TEMP:
case H8_CTL_TEMP_CUTOUT:
case H8_CTL_WAKEUP:
case H8_CTL_CHG_THRESHOLD:
case H8_CTL_TURBO_MODE:
case H8_SET_DIAG_STATUS:
case H8_SOFTWARE_RESET:
case H8_RECAL_PTR:
case H8_SET_INT_BATT_PERCENT:
case H8_WRT_CFG_INTERFACE_REG:
case H8_WRT_EVENT_STATUS_MASK:
case H8_ENTER_POST_MODE:
case H8_EXIT_POST_MODE:
case H8_RD_EEPROM:
case H8_WRT_EEPROM:
case H8_WRT_TO_STATUS_DISP:
printk("H8: Write IO status display command done\n");
break;
case H8_DEFINE_SPC_CHAR:
case H8_DEFINE_TABLE_STRING_ENTRY:
case H8_PERFORM_EMU_CMD:
case H8_EMU_RD_REG:
case H8_EMU_WRT_REG:
case H8_EMU_RD_RAM:
case H8_EMU_WRT_RAM:
case H8_BQ_RD_REG:
case H8_BQ_WRT_REG:
case H8_PWR_OFF:
printk (KERN_DEBUG "H8: misc command completed\n");
break;
}
return;
}
/*
* Retrieve the current CPU temperature and case temperature. Provides
* the feedback for the thermal control algorithm. Synchcronized via
* sleep() for priority so that no other actions in the process will take
* place before the data becomes available.
*/
int
h8_get_curr_temp(u_char curr_temp[])
{
u_char buf[H8_MAX_CMD_SIZE];
unsigned long flags;
memset(buf, 0, H8_MAX_CMD_SIZE);
buf[0] = H8_RD_CURR_TEMP;
h8_q_cmd(buf, 1, 2);
save_flags(flags); cli();
while((h8_sync_channel & H8_RD_CURR_TEMP) == 0)
sleep_on(&h8_sync_wait);
restore_flags(flags);
h8_sync_channel &= ~H8_RD_CURR_TEMP;
curr_temp[0] = xx.byte[0];
curr_temp[1] = xx.byte[1];
xx.word = 0;
if(h8_debug & 0x8)
printk("H8: curr CPU temp %d, Sys temp %d\n",
curr_temp[0], curr_temp[1]);
return 0;
}
static void
h8_get_max_temp(void)
{
u_char buf[H8_MAX_CMD_SIZE];
buf[0] = H8_RD_MAX_TEMP;
h8_q_cmd(buf, 1, 2);
}
/*
* Assigns an upper limit to the value of the H8 thermal interrupt.
* As an example setting a value of 115 F here will cause the
* interrupt to trigger when the CPU temperature reaches 115 F.
*/
static void
h8_set_upper_therm_thold(int thold)
{
u_char buf[H8_MAX_CMD_SIZE];
/* write 0 to reinitialize interrupt */
buf[0] = H8_CTL_UPPER_TEMP;
buf[1] = 0x0;
buf[2] = 0x0;
h8_q_cmd(buf, 3, 1);
/* Do it for real */
buf[0] = H8_CTL_UPPER_TEMP;
buf[1] = 0x0;
buf[2] = thold;
h8_q_cmd(buf, 3, 1);
}
static void
h8_get_upper_therm_thold(void)
{
u_char buf[H8_MAX_CMD_SIZE];
buf[0] = H8_CTL_UPPER_TEMP;
buf[1] = 0xff;
buf[2] = 0;
h8_q_cmd(buf, 3, 1);
}
/*
* The external status word contains information on keyboard controller,
* power button, changes in external batt status, change in DC state,
* docking station, etc. General purpose querying use.
*/
int
h8_get_ext_status(u_char stat_word[])
{
u_char buf[H8_MAX_CMD_SIZE];
unsigned long flags;
memset(buf, 0, H8_MAX_CMD_SIZE);
buf[0] = H8_RD_EXT_STATUS;
h8_q_cmd(buf, 1, 2);
save_flags(flags); cli();
while((h8_sync_channel & H8_GET_EXT_STATUS) == 0)
sleep_on(&h8_sync_wait);
restore_flags(flags);
h8_sync_channel &= ~H8_GET_EXT_STATUS;
stat_word[0] = xx.byte[0];
stat_word[1] = xx.byte[1];
xx.word = 0;
if(h8_debug & 0x8)
printk("H8: curr ext status %x, %x\n",
stat_word[0], stat_word[1]);
return 0;
}
/*
* Thread attached to task 0 manages thermal/physcial state of Alphabook.
* When a condition is detected by the interrupt service routine, the
* isr does a wakeup() on h8_monitor_wait. The mask value is then
* screened for the appropriate action.
*/
int
h8_monitor_thread(void * unused)
{
u_char curr_temp[2];
/*
* Need a logic based safety valve here. During boot when this thread is
* started and the thermal interrupt is not yet initialized this logic
* checks the temperature and acts accordingly. When this path is acted
* upon system boot is painfully slow, however, the priority associated
* with overheating is high enough to warrant this action.
*/
h8_get_curr_temp(curr_temp);
printk(KERN_INFO "H8: Initial CPU temp: %d\n", curr_temp[0]);
if(curr_temp[0] >= h8_uthermal_threshold) {
h8_set_event_mask(H8_MANAGE_UTHERM);
h8_manage_therm();
} else {
/*
* Arm the upper thermal limit of the H8 so that any temp in
* excess will trigger the thermal control mechanism.
*/
h8_set_upper_therm_thold(h8_uthermal_threshold);
}
for(;;) {
sleep_on(&h8_monitor_wait);
if(h8_debug & 0x2)
printk(KERN_DEBUG "h8_monitor_thread awakened, mask:%x\n",
h8_event_mask);
if (h8_event_mask & (H8_MANAGE_UTHERM|H8_MANAGE_LTHERM)) {
h8_manage_therm();
}
#if 0
if (h8_event_mask & H8_POWER_BUTTON) {
h8_system_down();
}
/*
* If an external DC supply is removed or added make
* appropriate CPU speed adjustments.
*/
if (h8_event_mask & H8_MANAGE_BATTERY) {
h8_run_level_3_manage(H8_RUN);
h8_clear_event_mask(H8_MANAGE_BATTERY);
}
#endif
}
}
/*
* Function implements the following policy. When the machine is booted
* the system is set to run at full clock speed. When the upper thermal
* threshold is reached as a result of full clock a damping factor is
* applied to cool off the cpu. The default value is one quarter clock
* (57 Mhz). When as a result of this cooling a temperature lower by
* hmc_uthermal_window is reached, the machine is reset to a higher
* speed, one half clock (115 Mhz). One half clock is maintained until
* the upper thermal threshold is again reached restarting the cycle.
*/
int
h8_manage_therm(void)
{
u_char curr_temp[2];
if(h8_event_mask & H8_MANAGE_UTHERM) {
/* Upper thermal interrupt received, need to cool down. */
if(h8_debug & 0x10)
printk(KERN_WARNING "H8: Thermal threshold %d F reached\n",
h8_uthermal_threshold);
h8_set_cpu_speed(h8_udamp);
h8_clear_event_mask(H8_MANAGE_UTHERM);
h8_set_event_mask(H8_MANAGE_LTHERM);
/* Check again in 30 seconds for CPU temperature */
h8_start_monitor_timer(H8_TIMEOUT_INTERVAL);
} else if (h8_event_mask & H8_MANAGE_LTHERM) {
/* See how cool the system has become as a result
of the reduction in speed. */
h8_get_curr_temp(curr_temp);
last_temp = curr_temp[0];
if (curr_temp[0] < (h8_uthermal_threshold - h8_uthermal_window))
{
/* System cooling has progressed to a point
that the CPU may be sped up. */
h8_set_upper_therm_thold(h8_uthermal_threshold);
h8_set_cpu_speed(h8_ldamp); /* adjustable */
if(h8_debug & 0x10)
printk(KERN_WARNING "H8: CPU cool, applying cpu_divisor: %d \n",
h8_ldamp);
h8_clear_event_mask(H8_MANAGE_LTHERM);
}
else /* Not cool enough yet, check again in 30 seconds. */
h8_start_monitor_timer(H8_TIMEOUT_INTERVAL);
} else {
}
return 0;
}
/*
* Function conditions the value of global_rpb_counter before
* calling the primitive which causes the actual speed change.
*/
void
h8_set_cpu_speed(int speed_divisor)
{
#ifdef NOT_YET
/*
* global_rpb_counter is consumed by alpha_delay() in determining just
* how much time to delay. It is necessary that the number of microseconds
* in DELAY(n) be kept consistent over a variety of CPU clock speeds.
* To that end global_rpb_counter is here adjusted.
*/
switch (speed_divisor) {
case 0:
global_rpb_counter = rpb->rpb_counter * 2L;
break;
case 1:
global_rpb_counter = rpb->rpb_counter * 4L / 3L ;
break;
case 3:
global_rpb_counter = rpb->rpb_counter / 2L;
break;
case 4:
global_rpb_counter = rpb->rpb_counter / 4L;
break;
case 5:
global_rpb_counter = rpb->rpb_counter / 8L;
break;
/*
* This case most commonly needed for cpu_speed_divisor
* of 2 which is the value assigned by the firmware.
*/
default:
global_rpb_counter = rpb->rpb_counter;
break;
}
#endif /* NOT_YET */
if(h8_debug & 0x8)
printk(KERN_DEBUG "H8: Setting CPU speed to %d MHz\n",
speed_tab[speed_divisor]);
/* Make the actual speed change */
lca_clock_fiddle(speed_divisor);
}
/*
* Gets value stored in rpb representing CPU clock speed and adjusts this
* value based on the current clock speed divisor.
*/
u_long
h8_get_cpu_speed(void)
{
u_long speed = 0;
u_long counter;
#ifdef NOT_YET
counter = rpb->rpb_counter / 1000000L;
switch (alphabook_get_clock()) {
case 0:
speed = counter * 2L;
break;
case 1:
speed = counter * 4L / 3L ;
break;
case 2:
speed = counter;
break;
case 3:
speed = counter / 2L;
break;
case 4:
speed = counter / 4L;
break;
case 5:
speed = counter / 8L;
break;
default:
break;
}
if(h8_debug & 0x8)
printk(KERN_DEBUG "H8: CPU speed current setting: %d MHz\n", speed);
#endif /* NOT_YET */
return speed;
}
static void
h8_activate_monitor(unsigned long unused)
{
unsigned long flags;
save_flags(flags); cli();
h8_monitor_timer_active = 0;
restore_flags(flags);
wake_up(&h8_monitor_wait);
}
static void
h8_start_monitor_timer(unsigned long secs)
{
unsigned long flags;
if (h8_monitor_timer_active)
return;
save_flags(flags); cli();
h8_monitor_timer_active = 1;
restore_flags(flags);
init_timer(&h8_monitor_timer);
h8_monitor_timer.function = h8_activate_monitor;
h8_monitor_timer.expires = secs * HZ + jiffies;
add_timer(&h8_monitor_timer);
}
static void h8_set_event_mask(int mask)
{
unsigned long flags;
save_flags(flags); cli();
h8_event_mask |= mask;
restore_flags(flags);
}
static void h8_clear_event_mask(int mask)
{
unsigned long flags;
save_flags(flags); cli();
h8_event_mask &= (~mask);
restore_flags(flags);
}
MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;
|