URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [char/] [h8.c] - Blame information for rev 1772

Go to most recent revision | Details | Compare with Previous | View Log

/*
 */
/*
 * Hitachi H8/337 Microcontroller driver
 *
 * The H8 is used to deal with the power and thermal environment
 * of a system.
 */
 
#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/malloc.h>
#include <linux/linkage.h>
#ifdef CONFIG_PROC_FS
#include <linux/stat.h>
#include <linux/proc_fs.h>
#endif
#include <linux/miscdevice.h>
#include <linux/lists.h>
#include <linux/ioport.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.
 */
int          h8_init(void);
int          h8_display_blank(void);
int          h8_display_unblank(void);
 
static int   h8_open(struct inode *, struct file *);
static void  h8_release(struct inode *, struct file *);
static long  h8_read(struct inode *, struct file *, char *, u_long);
static int   h8_select(struct inode *, struct file *, int, select_table *);
static int   h8_ioctl(struct inode *, struct file *, u_int, u_long);
 
static void  h8_intr(int irq, void *dev_id, struct pt_regs *regs);
 
#ifdef CONFIG_PROC_FS
static int   h8_get_info(char *, char **, off_t, int, int);
#endif
 
/*
 * 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 struct file_operations h8_fops = {
        NULL,           /* lseek */
        h8_read,
        NULL,           /* write */
        NULL,           /* readdir */
        h8_select,
        h8_ioctl,
        NULL,           /* mmap */
        h8_open,
        h8_release,
        NULL,           /* fsync */
        NULL            /* fasync */
};
 
static struct miscdevice h8_device = {
        H8_MINOR_DEV,
        "h8",
        &h8_fops
};
 
#ifdef CONFIG_PROC_FS
static struct proc_dir_entry    h8_proc_entry = {
        0, 3, "h8", S_IFREG | S_IRUGO, 1, 0, 0, 0, 0, h8_get_info
};
#endif
 
union   intr_buf intrbuf;
int     intr_buf_ptr;
union   intr_buf xx;
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)
 
unsigned int h8_base = H8_BASE_ADDR;
unsigned int h8_irq = H8_IRQ;
unsigned int h8_state = H8_IDLE;
unsigned int h8_index = -1;
unsigned int h8_enabled = 0;
 
queue_head_t h8_actq, h8_cmdq, h8_freeq;
 
/*
 * Globals used in thermal control of Alphabook1.
 */
int cpu_speed_divisor = -1;
int h8_event_mask = 0;
struct wait_queue *h8_monitor_wait = NULL;
unsigned int h8_command_mask = 0;
int h8_uthermal_threshold = DEFAULT_UTHERMAL_THRESHOLD;
int h8_uthermal_window = UTH_HYSTERESIS;
int h8_debug = 0xfffffdfc;
int h8_ldamp = MHZ_115;
int h8_udamp = MHZ_57;
u_char h8_current_temp = 0;
u_char h8_system_temp = 0;
int h8_sync_channel = 0;
struct wait_queue *h8_sync_wait = NULL;
int h8_init_performed;
 
/* CPU speeds and clock divisor values */
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 = (h8_cmd_q_t *)QUEUE_FIRST(&h8_actq, 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 (!QUEUE_EMPTY(&h8_actq, link))
                    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;
                    QUEUE_REMOVE(&h8_actq, qp, link);
                    h8_cmd_done (qp);
                    /* More commands to send over? */
                    if (!QUEUE_EMPTY(&h8_cmdq, link))
                        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;
}
 
#ifdef MODULE
 
int init_module(void)
{
        printk("H8 module at %X(Interrupt %d)\n", h8_base, h8_irq);
        if(request_irq(h8_irq, h8_intr, SA_INTERRUPT, "h8", NULL))
        {
                printk("H8: error: IRQ %d is not free.\n", h8_irq);
                return -EIO;
        }
 
        misc_register(&h8_device);
        request_region(h8_base, 8, "h8");
 
#ifdef CONFIG_PROC_FS
        proc_register_dynamic(&proc_root, &h8_proc_entry);
#endif
 
        QUEUE_INIT(&h8_actq, link, h8_cmd_q_t *);
        QUEUE_INIT(&h8_cmdq, link, h8_cmd_q_t *);
        QUEUE_INIT(&h8_freeq, link, h8_cmd_q_t *);
        h8_alloc_queues();
 
        h8_hw_init();
 
        kernel_thread(h8_monitor_thread, NULL, 0);
 
        return 0;
}
 
void cleanup_module(void)
{
        misc_deregister(&h8_device);
        release_region(h8_base, 8);
        free_irq(h8_irq, NULL);
}
 
#else /* MODULE */
 
int h8_init(void)
{
        if(request_irq(h8_irq, h8_intr, SA_INTERRUPT, "h8", NULL))
        {
                printk("H8: error: IRQ %d is not free\n", h8_irq);
                return -EIO;
        }
        printk("H8 at 0x%x IRQ %d\n", h8_base, h8_irq);
 
#ifdef CONFIG_PROC_FS
        proc_register_dynamic(&proc_root, &h8_proc_entry);
#endif
 
        misc_register(&h8_device);
        request_region(h8_base, 8, "h8");
 
        QUEUE_INIT(&h8_actq, link, h8_cmd_q_t *);
        QUEUE_INIT(&h8_cmdq, link, h8_cmd_q_t *);
        QUEUE_INIT(&h8_freeq, link, h8_cmd_q_t *);
        h8_alloc_queues();
 
        h8_hw_init();
 
        kernel_thread(h8_monitor_thread, NULL, 0);
 
        return 0;
}
#endif /* MODULE */
 
void 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;
}
 
#ifdef CONFIG_PROC_FS
int h8_get_info(char *buf, char **start, off_t fpos, int length, int dummy)
{
        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;
}
#endif
 
static long h8_read(struct inode *inode, struct file *fp, char *buf,
                    u_long count)
{
        printk("h8_read: IMPDEL\n");
        return 0;
}
 
static int h8_select(struct inode *inode, struct file *fp, int sel_type,
                     select_table * wait)
{
        printk("h8_select: IMPDEL\n");
        return 0;
}
 
static int h8_ioctl(struct inode * inode, struct file *filp,
                    u_int cmd, u_long arg)
{
        printk("h8_ioctl: IMPDEL\n");
        return 0;
}
 
static void h8_release(struct inode * inode, struct file * filp)
{
        printk("h8_release: IMPDEL\n");
}
 
static int h8_open(struct inode * inode, struct file * filp)
{
        printk("h8_open: IMPDEL\n");
        return 0;
}
 
/* Called from console driver -- must make sure h8_enabled. */
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. */
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;
}
 
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("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 */
                QUEUE_ENTER(&h8_freeq, &qp[i], link, h8_cmd_q_t *);
        }
        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 (QUEUE_EMPTY(&h8_freeq, link)) {
                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 = (h8_cmd_q_t *)QUEUE_FIRST(&h8_freeq, link);
        QUEUE_REMOVE(&h8_freeq, 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();
 
        QUEUE_ENTER(&h8_cmdq, qp, link, h8_cmd_q_t *);
 
        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 (!QUEUE_EMPTY(&h8_actq, link)) {
                Dprintk("h8_start_new_cmd: inconsistency: IDLE with non-empty active queue!\n");
                restore_flags(flags);
                return;
        }
 
        if (QUEUE_EMPTY(&h8_cmdq, link)) {
                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 = (h8_cmd_q_t *) QUEUE_FIRST(&h8_cmdq, link);
        QUEUE_REMOVE(&h8_cmdq, qp, link);
        QUEUE_ENTER(&h8_actq, qp, link, h8_cmd_q_t *);
        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 = (h8_cmd_q_t *)QUEUE_FIRST(&h8_actq, 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("h8_read_event_status: value 0x%x\n", intrbuf.word);
 
        /*
         * Power related items
         */
        if (intrbuf.word & H8_DC_CHANGE) {
                if(h8_debug & 0x4)
                    printk("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("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("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("h8_read_event_status: DOCKING_STATION_STATUS\n");
                /* read_ext_status */
        }
        if (intrbuf.word & H8_EXT_BATT_STATUS) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: EXT_BATT_STATUS\n");
 
        }
        if (intrbuf.word & H8_EXT_BATT_CHARGE_STATE) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: EXT_BATT_CHARGE_STATE\n");
 
        }
        if (intrbuf.word & H8_BATT_CHANGE_OVER) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: BATT_CHANGE_OVER\n");
 
        }
        if (intrbuf.word & H8_WATCHDOG) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: WATCHDOG\n");
                /* nop */
        }
        if (intrbuf.word & H8_SHUTDOWN) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: SHUTDOWN\n");
                /* nop */
        }
        if (intrbuf.word & H8_KEYBOARD) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: KEYBOARD\n");
                /* nop */
        }
        if (intrbuf.word & H8_EXT_MOUSE_OR_CASE_SWITCH) {
                if(h8_debug & 0x4)
                    printk("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("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("h8_read_event_status: INT_BATT_CHARGE_STATE\n");
                /* nop - happens often */
        }
        if (intrbuf.word & H8_INT_BATT_STATUS) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: INT_BATT_STATUS\n");
 
        }
        if (intrbuf.word & H8_INT_BATT_CHARGE_THRESHOLD) {
                if(h8_debug & 0x4)
                    printk("h8_read_event_status: INT_BATT_CHARGE_THRESHOLD\n");
                /* nop - happens often */
        }
        if (intrbuf.word & H8_EXT_BATT_LOW) {
                if(h8_debug & 0x4)
                    printk("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.
 */
void
h8_cmd_done(h8_cmd_q_t *qp)
{
 
        /* what to do */
        switch (qp->cmdbuf[0]) {
        case H8_SYNC:
            if (h8_debug & 0x40000)
                printk("H8: Sync command done - byte returned was 0x%x\n",
                       qp->rcvbuf[0]);
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            break;
 
        case H8_RD_SN:
        case H8_RD_ENET_ADDR:
            printk("H8: Read ethernet addr - 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]);
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            break;
 
        case H8_RD_HW_VER:
        case H8_RD_MIC_VER:
        case H8_RD_MAX_TEMP:
            printk("H8: Max recorded CPU temp %d, Sys temp %d\n",
                   qp->rcvbuf[0], qp->rcvbuf[1]);
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            break;
 
        case H8_RD_MIN_TEMP:
            printk("H8: Min recorded CPU temp %d, Sys temp %d\n",
                   qp->rcvbuf[0], qp->rcvbuf[1]);
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            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);
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            break;
 
        case H8_RD_SYS_VARIENT:
        case H8_RD_PWR_ON_CYCLES:
            printk(" H8: RD_PWR_ON_CYCLES command done\n");
            break;
 
        case H8_RD_PWR_ON_SECS:
            printk("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);
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            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("H8: Read int batt status cmd done - returned was %x %x %x\n",
                   qp->rcvbuf[0], qp->rcvbuf[1], qp->rcvbuf[2]);
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            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("H8: Device control cmd done - byte returned was 0x%x\n",
                       qp->rcvbuf[0]);
            }
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            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("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]);
            }
            QUEUE_ENTER(&h8_freeq, qp, link, h8_cmd_q_t *);
            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 ("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("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("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("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 speeded up. */
                        h8_set_upper_therm_thold(h8_uthermal_threshold);
                        h8_set_cpu_speed(h8_ldamp); /* adjustable */
                        if(h8_debug & 0x10)
                            printk("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("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("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);
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [char/] [h8.c] - Blame information for rev 1772

Line No.	Rev	Author	Line
1	1626	jcastillo	`/*`
2			`*/`
3			`/*`
4			`* Hitachi H8/337 Microcontroller driver`
5			`*`
6			`* The H8 is used to deal with the power and thermal environment`
7			`* of a system.`
8			`*/`
9
10			`#include <linux/config.h>`
11			`#include <linux/module.h>`
12
13			`#include <asm/system.h>`
14			`#include <asm/segment.h>`
15			`#include <asm/io.h>`
16
17			`#include <linux/types.h>`
18			`#include <linux/stddef.h>`
19			`#include <linux/timer.h>`
20			`#include <linux/fcntl.h>`
21			`#include <linux/malloc.h>`
22			`#include <linux/linkage.h>`
23			`#ifdef CONFIG_PROC_FS`
24			`#include <linux/stat.h>`
25			`#include <linux/proc_fs.h>`
26			`#endif`
27			`#include <linux/miscdevice.h>`
28			`#include <linux/lists.h>`
29			`#include <linux/ioport.h>`
30
31			`#define __KERNEL_SYSCALLS__`
32			`#include <asm/unistd.h>`
33
34			`#include "h8.h"`
35
36			`#define DEBUG_H8`
37
38			`#ifdef DEBUG_H8`
39			`#define Dprintk printk`
40			`#else`