#include <linux/pc_keyb.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/malloc.h>
#include <linux/fcntl.h>
#include <linux/fs.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/mm.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/segment.h>

struct tq_struct pos_keyb_task;		

static long msr_size = 400l;
static int  pos_kb_major = 121;     /* for locat use avalble */
static int  keyb_typ = 0;           /* Siemens TA85 .. */
void pos_kb_bh_handler(void * unused);

#define POS_KBD_KEYLOCK_ENABLE 0xd1

typedef  struct { 
     pc_keyb_t pckb;
     char * msr_buff;
     int  msr_count; 
     int  keystat; 
     char keypos;
} pos_kb_t;

static volatile pos_kb_t * pos_kb;

int pos_keyb_event (unsigned char * scancode)
{
   printk("pos_kb: %x\n", *scancode);

   if (*scancode == KBD_REPLY_POR)
   {
       pos_keyb_task.sync = 0;
       pos_keyb_task.routine = pos_kb_bh_handler;
       queue_task(&pos_keyb_task, &tq_immediate);
       mark_bh(IMMEDIATE_BH);
       return 1;
   } /* else if (scancode ==   */

   return 1;	
}

void pos_kb_bh_handler(void * unused)
{
    // pos_kb->pckb.kbd_write_output_w(POS_KBD_KEYLOCK_ENABLE);
}


int pos_kb_open (struct inode * inode, struct file * filp)
{
    MOD_INC_USE_COUNT;
    pos_kb  = (pos_kb_t *) kmalloc( sizeof(pos_kb_t) + msr_size, GFP_KERNEL);

    if (pos_kb == NULL)
    {
        MOD_DEC_USE_COUNT;
        return  -ENOMEM;
    }
    pos_kb->msr_buff  = ((char *) pos_kb) + sizeof(pos_kb_t);
    pos_kb->keypos	  = 0;
    pos_kb->keystat   = 0;
    pos_kb->msr_count = 0;
    pos_kb->pckb.do_acknowledge  = NULL;
    pos_kb->pckb.kbd_check_event = pos_keyb_event;  
 
    filp->private_data = (void*) pos_kb; 

    register_kbd_ex (&pos_kb->pckb);

    pos_kb->pckb.kbd_write_output_w(KBD_CMD_RESET);
    return 0;
}

ssize_t pos_kb_read (struct file * filp, char * buf, size_t len , loff_t * offp)
{
    pos_kb_t * kb = filp->private_data;
    return 0;
}


int pos_kb_release (struct inode * inode, struct file *filp)
{
    pos_kb_t * kb = filp->private_data;

    unregister_kbd_ex (&kb->pckb);

    if (kb != NULL)
	 kfree(kb);    

    MOD_DEC_USE_COUNT;
    return 0;    
}

int pos_kb_ioctl (struct inode *inode, struct file * filp, 
			unsigned int command, unsigned long arg)
{
    pos_kb_t * kb = filp->private_data;
    int err = 0;

    return err;
}

static struct file_operations pos_kb_fops = {
read:	 pos_kb_read, /* bdr_read*/  
ioctl:   pos_kb_ioctl,
open:	 pos_kb_open,
release: pos_kb_release,	
};

int init_module(void)
{
    int result;
    
    result = register_chrdev(pos_kb_major,"pos_kb",&pos_kb_fops); 

    if (result < 0)
    {
        printk(KERN_WARNING "pos_kb: can't get major %d\n", pos_kb_major);
	return result;
    }	 
    if (pos_kb_major == 0) 
	pos_kb_major = result;   /* dynamic */

    return 0;
}

void cleanup_module(void)
{
    unregister_chrdev(pos_kb_major,"pos_keyb");   
    return;
}