clps711x_keyb.c

linux和2410结合开发 用他可以生成2410所需的zImage文件

		if (khandy.ena && KEYISPRINTABLE(act_scancode[scode]))
			khandy.autocomplete = 1;
		else
			handle_scancode(scode + khandy.shift, down);
		return;	
	}
	
	khandy.autocomplete = 0;
	if (KEYISPRINTABLE(kcode)) {
		if (khandy.code) {	
			if(khandy.code == (scode|0x100)) {
				handle_scancode(khandy.del,1);
				handle_scancode(khandy.del,0);
				khandy.shift = khandy.shift < 3*64 ? khandy.shift + 64 : 0 ;
			} else {
				handle_scancode(khandy.right,1);
				handle_scancode(khandy.right,0);
				khandy.shift = 0;
			}			
		}
		handle_scancode(scode + khandy.shift, 1);
		handle_scancode(scode + khandy.shift, 0);
		khandy.code = scode | 0x100;
		handle_scancode(khandy.left,1);
		handle_scancode(khandy.left,0);
	} else {
		if (khandy.code) {
			khandy.code = 0;
			handle_scancode(khandy.right,1);
			handle_scancode(khandy.right,0);
		}
		khandy.shift = 0;
		handle_scancode(scode, down);
	}
}


/*
 * Process the new key data 
 */
static void clps711x_kbd_process(void* data)
{
	int col,row,res;

	for (col = 0; col < 8; col++) {
		if (( res = previous_keys[col] ^ keys[col]) == 0) 		
			continue;
		for(row = 0; row < 8; row++) {
			if ( ((res >> row) & 0x01) != 0) 
				clps711x_checkhandy(col,row);	
		}				
	}
	/* Update the state variables. */
	memcpy(previous_keys, keys, 8 * sizeof(int));

	/* reschedule, if autocomplete pending */
	if (khandy.autocomplete) {
		khandy.expires = jiffies + khandy.delay;
		mod_timer(&clps711x_kbdhandy_timer,khandy.expires);
	}

}

static char clps711x_unexpected_up(unsigned char scancode)
{
	return 0200;
}

/*
* Handle timer event, for autocomplete function
* Reschedule keyboard process task
*/
static void clps711x_kbdhandy_timeout(unsigned long data) 
{
	if(khandy.autocomplete) {
		khandy.code = 0;
		khandy.shift = 0;
		khandy.autocomplete = 0;
		handle_scancode(khandy.right,1);
		handle_scancode(khandy.right,0);
	}
}

/*
* Handle timer event, while in pollmode
*/
static void clps711x_kbd_timeout(unsigned long data)
{
	int i;
	unsigned long flags;
	/* 
	* read bits of actual column or all columns in fastscan-mode
	*/
	for (i = 0; i < 8; i++) {
		new_keys[last_column - KBSC_COL0] = clps_readb(PADR) & 0xff;
		key_is_pressed |= new_keys[last_column - KBSC_COL0];
		last_column = last_column < KBSC_COL7 ? last_column + 1 : KBSC_COL0;
		local_irq_save(flags);
		clps_writel( (clps_readl(SYSCON1) & ~SYSCON1_KBDSCANMASK) 
				| last_column, SYSCON1);
		local_irq_restore(flags);
		/*
		* For fastscan, apply a short delay to settle scanlines
		* else break and wait for next timeout
		*/
		if (fastscan)
			udelay(5);	
		else
			break;
	}

	if (key_is_pressed)
		khandy.autocomplete = 0;

	/*
	* switch to interupt mode, if all columns scanned and no key pressed
	* else reschedule scan
	*/
	if (last_column == KBSC_COL0) {
		if (!key_is_pressed) {
			local_irq_save(flags);
			clps_writel( (clps_readl(SYSCON1) & ~SYSCON1_KBDSCANMASK)
					 | KBSC_HI, SYSCON1);
			local_irq_restore(flags);
			clps_writel(0,KBDEOI);	
			enable_irq(IRQ_KBDINT);
		} else {
			clps711x_kbd_timer.expires = jiffies + scan_interval;
			add_timer(&clps711x_kbd_timer);
		}		
		key_is_pressed = 0;
		memcpy(keys, new_keys, 8 * sizeof(int));
		for (i = 0; i < 8; i++) {
			if (previous_keys[i] != keys[i]) {
				queue_task(&kbd_process_task, &tq_timer);
				return;
			}
		}
	} else {
		clps711x_kbd_timer.expires = jiffies + scan_delay;
		add_timer(&clps711x_kbd_timer);
	}
}

/*
* Keyboard interrupt, change to scheduling mode
*/
static void clps711x_kbd_int(int irq, void *dev_id, struct pt_regs *regs)
{

#ifdef CONFIG_VT
	kbd_pt_regs = regs;
#endif
	disable_irq(IRQ_KBDINT);
	khandy.autocomplete = 0;
	clps_writel( (clps_readl(SYSCON1) & ~SYSCON1_KBDSCANMASK)
		 | KBSC_COL0, SYSCON1);
	clps711x_kbd_timer.expires = jiffies + scan_delay;
	add_timer(&clps711x_kbd_timer);
}


static int clps711x_kbd_proc_keyboard_read(char *page, char **start, off_t off,
		int count, int *eof, void *data)
{
	if (count < 2) 
		return -EINVAL;

	return sprintf(page,"h:%d\n",khandy.ena);
}

static int clps711x_kbd_proc_keyboard_write(struct file *file, const char *buffer, 
		unsigned long count, void *data)
{
	unsigned char buf[260];

	if (count < 3|| count > 258)
		return -EINVAL;
	if (copy_from_user(buf, buffer, count)) 
		return -EFAULT;
	if (buf[1] != ':')
		return -EINVAL;
			
	if (buf[0] == 'h') {
		switch (buf[2]) {
			case '0':
			case '1':
			case '2': khandy.ena = buf[2]-'0'; return count;	
		}
	}	
		
	if (buf[0] == 't' && count == 258) {
		memcpy(act_scancode,buf+2,256);
		/* rescan cursor left/right and del */ 
		clps711x_handykey_init();
		return count;
	}
	
	return -EINVAL;
}


/*
 * Initialize the keyboard hardware. 
 * Set all columns high
 * Install interrupt handler
 *
 * Machine dependent parameters:
 *
 * fastscan: 		0 = timer based scan for each column
 *			1 = full scan is done in one timer event
 * scan_delay:		time between column scans 
 * 			setup even if you use fastscan (leeds to timer mode)
 * scan_interval:	time between full scans
 * handy.delay:		timeout before last entry get's automatically valid
 * 
 */
void __init clps711x_kbd_init_hw(void)
{

	/*
	* put here  machine dependent init stuff 
	*/
	if (machine_is_autcpu12()) {
		fastscan = 0;
		scan_interval = 50*HZ/1000;
		scan_delay = 20*HZ/1000;
		khandy.delay = 750*HZ/1000;
		act_scancode = autcpu12_scancode;
	} else {
		printk("No initialization, keyboard killed\n");
		return;
	}

	last_column = KBSC_COL0;
	key_is_pressed = 0;

	clps711x_handykey_init();

	/* Register the /proc entry */
	clps711x_keyboard_proc_entry = create_proc_entry("keyboard", 0444,
		&proc_root);
	if (clps711x_keyboard_proc_entry == NULL)
	    	printk("Couldn't create the /proc entry for the keyboard\n");
	else {
		clps711x_keyboard_proc_entry->read_proc = 
			&clps711x_kbd_proc_keyboard_read;
		clps711x_keyboard_proc_entry->write_proc = 
			&clps711x_kbd_proc_keyboard_write;
	}

	/* Initialize the matrix processing task. */
	k_translate	= clps711x_translate;
	k_unexpected_up	= clps711x_unexpected_up;
	kbd_process_task.routine = clps711x_kbd_process;
	kbd_process_task.data = 0;
	
	/* Setup the timer for keyboard polling, after kbd int */
	init_timer(&clps711x_kbd_timer);
	clps711x_kbd_timer.function = clps711x_kbd_timeout;
	clps711x_kbd_timer.data = 0;
	init_timer(&clps711x_kbdhandy_timer);
	clps711x_kbdhandy_timer.function = clps711x_kbdhandy_timeout;
	clps711x_kbdhandy_timer.data = 1;

	/* Initialise scan hardware, request int */
	clps_writel( (clps_readl(SYSCON1) & ~SYSCON1_KBDSCANMASK)
		 | KBSC_HI, SYSCON1);
	request_irq(IRQ_KBDINT, clps711x_kbd_int, 0,"keyboard", NULL);

	printk("clps711x keyboard init done\n");

}