dn_keyb.c

powerpc内核mpc8241linux系统下char驱动程序

        return 0;
}

static ssize_t write_mouse(struct file * file, const char * buffer,
			   size_t count, loff_t *ppos)
{
        return -EINVAL;
}

static ssize_t read_mouse(struct file * file, char * buffer,
			  size_t count, loff_t *ppos)
{
	int dx,dy,r;
	unsigned char buttons;

	if (count < 3)
		return -EINVAL;
	if ((r = verify_area(VERIFY_WRITE, buffer, count)))
   		return r;
	if (!mouse_ready)
		return -EAGAIN;	

	MSE_UPDATE_OFF();
	dx=mouse_dx;	
	dy=mouse_dy;	
	if (dx < -127)
		dx = -127;
	else
	if (dx > 127)
   		dx = 127;
	if (dy < -127)
   		dy = -127;
	else
	if (dy > 127)
   		dy = 127;
	buttons=(mouse_buttons & 1 ? 4 : 0) |
			(mouse_buttons & 2 ? 1 : 0) |
			(mouse_buttons & 4 ? 2 : 0);

	mouse_dx-=dx;
	mouse_dy-=dy;
	MSE_UPDATE_ON();

	if (put_user(buttons | 0x80, buffer++) ||
	    put_user((char)dx, buffer++) ||
	    put_user((char)dy, buffer++))
		return -EINVAL;

	if (count > 3)
		if (clear_user(buffer, count - 3))
			return -EFAULT;
	return count;
}

static int fasync_mouse(int fd, struct file *filp, int on)
{
        int retval;

        retval = fasync_helper(fd, filp, on, &mouse_fasyncptr);
        if (retval < 0)
                return retval;
        return 0;
}


static int release_mouse(struct inode * inode, struct file * file)
{
        fasync_mouse(-1, file, 0);
        if (--mouse_active)
                return 0;
        MSE_UPDATE_OFF();
        MOD_DEC_USE_COUNT;
        return 0;
}

static int open_mouse(struct inode * inode, struct file * file)
{
        if (mouse_active++)
                return 0;
        /*
         *  use VBL to poll mouse deltas
         */

        mouse_dx = 0;
        mouse_dy = 0;
        mouse_buttons = 0;
        mouse_active = 1;
        MOD_INC_USE_COUNT;
        MSE_UPDATE_ON();
        return 0;
}

static void dn_keyb_process_key_event(unsigned char scancode) {

	static unsigned char lastscancode;
	unsigned char prev_scancode=lastscancode;
	static unsigned int lastkeypress;
	
	lastscancode=scancode;

	/*  printk("scan: %02x, lastscan: %02X, prev_scancode: %02X\n",scancode,lastscancode,prev_scancode); */

	if(prev_scancode==APOLLO_KBD_MODE_CHANGE) {
		kbd_mode=scancode;
/*		printk("modechange: %d\n",scancode);*/
	}
	else if((scancode & (~BREAK_FLAG)) == DNKEY_CAPS) {
    	/* printk("handle_scancode: %02x\n",DNKEY_CAPS); */
		handle_scancode(DNKEY_CAPS);
		/*    printk("handle_scancode: %02x\n",BREAK_FLAG | DNKEY_CAPS); */
		handle_scancode(BREAK_FLAG | DNKEY_CAPS);
	}
	else if( (scancode == DNKEY_REPEAT) && (prev_scancode < 0x7e) &&
   			!(prev_scancode==DNKEY_CTRL || prev_scancode==DNKEY_LSHIFT ||
       	   	prev_scancode==DNKEY_RSHIFT || prev_scancode==DNKEY_REPT ||
       	  	prev_scancode==DNKEY_LALT || prev_scancode==DNKEY_RALT)) {
        		if(jiffies-lastkeypress > DNKEY_REPEAT_DELAY) {
			/*    	printk("handle_scancode: %02x\n",prev_scancode); */
           			handle_scancode(prev_scancode);
			  	}
	   			lastscancode=prev_scancode;
  			}
  	else {
	/*    	printk("handle_scancode: %02x\n",scancode);  */
   			handle_scancode(scancode);
   			lastkeypress=jiffies;
  	}
}

static void dn_keyb_process_mouse_event(unsigned char mouse_data) {

	static short mouse_byte_count=0;
	static u_char mouse_packet[3];
	
	mouse_packet[mouse_byte_count++]=mouse_data;

	if(mouse_byte_count==3) {
		if(mouse_packet[0]==APOLLO_KBD_MODE_CHANGE) {
			kbd_mode=mouse_packet[1];
			mouse_byte_count=0;
/*			printk("modechange: %d\n",mouse_packet[1]); */
			if(kbd_mode==APOLLO_KBD_MODE_KEYB)
				dn_keyb_process_key_event(mouse_packet[2]);
		}				
		if((mouse_packet[0] & 0x8f) == 0x80) {
			if(mouse_update_allowed) {
				mouse_ready=1;
				mouse_buttons=(mouse_packet[0] >> 4) & 0x7;
				mouse_dx+=mouse_packet[1] == 0xff ? 0 : (signed char)mouse_packet[1];
				mouse_dy+=mouse_packet[2] == 0xff ? 0 : (signed char)mouse_packet[2];
				wake_up_interruptible(&mouse_wait);
				if (mouse_dx < -2048)
              		mouse_dx = -2048;
          		else
          		if (mouse_dx >  2048)
              		mouse_dx =  2048;
          		if (mouse_dy < -2048)
              		mouse_dy = -2048;
          		else
          		if (mouse_dy >  2048)
              		mouse_dy =  2048;
				if (mouse_fasyncptr)
              		kill_fasync(mouse_fasyncptr, SIGIO);
			}
			mouse_byte_count=0;
/*			printk("mouse: %d, %d, %x\n",mouse_x,mouse_y,buttons); */
		}
	}
}

static void dn_keyb_int(int irq, void *dummy, struct pt_regs *fp) {

	unsigned char data;
  	unsigned long flags;
  	int scn2681_ints;

	do {
		scn2681_ints=sio01.isr_imr & 3;
		if(scn2681_ints & 2) {
			data=sio01.rhra_thra;
#if 0
			if(debug_buf_count<4096) {
				debug_buf[debug_buf_count++]=data;
				debug_buffer_updated=jiffies;	
				if(!debug_timer_running) {
					add_timer(&debug_keyb_timer);
					debug_keyb_timer.expires=jiffies+10;
					debug_timer_running=1;
				}
			}
			else
				debug_buf_overrun=1;
#endif
			if(sio01.sra_csra & 0x10) {
				printk("whaa overrun !\n");
				continue;
			}

			if(kbd_mode==APOLLO_KBD_MODE_KEYB)
				dn_keyb_process_key_event(data);
			else
				dn_keyb_process_mouse_event(data);
		}
	
		if(scn2681_ints & 1) {
			save_flags(flags);
			cli();
			if(keyb_cmd_write!=keyb_cmd_read) {
				sio01.rhra_thra=keyb_cmds[keyb_cmd_read++];
				if(keyb_cmd_read==APOLLO_KEYB_CMD_ENTRIES)
					keyb_cmd_read=0;
				keyb_cmd_transmit=1;
			}
			else {
				keyb_cmd_transmit=0;
				sio01.BRGtest_cra=9;
			}
			restore_flags(flags);
		}
	} while(scn2681_ints) ;
}

void write_keyb_cmd(u_short length, u_char *cmd) {

  	unsigned long flags;

	if((keyb_cmd_write==keyb_cmd_read) && keyb_cmd_transmit)
		return;

	save_flags(flags);
	cli();
	for(;length;length--) {
		keyb_cmds[keyb_cmd_write++]=*(cmd++);
		if(keyb_cmd_write==keyb_cmd_read)
			return;
		if(keyb_cmd_write==APOLLO_KEYB_CMD_ENTRIES)
			keyb_cmd_write=0;
	}
	if(!keyb_cmd_transmit)  {
 	   sio01.BRGtest_cra=5;
	}
	restore_flags(flags);

}

struct file_operations apollo_mouse_fops = {
        NULL,           /* mouse_seek */
        read_mouse,
        write_mouse,
        NULL,           /* mouse_readdir */
        mouse_poll,     /* mouse_poll */
        NULL,           /* mouse_ioctl */
        NULL,           /* mouse_mmap */
        open_mouse,
	NULL,		/* flush */
        release_mouse,
        NULL,
        fasync_mouse,
};

static struct miscdevice apollo_mouse = {
        APOLLO_MOUSE_MINOR, "apollomouse", &apollo_mouse_fops
};

__initfunc(int dn_keyb_init(void)) {

/*  printk("dn_keyb_init\n"); */

  memcpy(key_maps[0], dnplain_map, sizeof(plain_map));
  memcpy(key_maps[1], dnshift_map, sizeof(plain_map));
  memcpy(key_maps[2], dnaltgr_map, sizeof(plain_map));
  memcpy(key_maps[4], dnctrl_map, sizeof(plain_map));
  memcpy(key_maps[5], dnshift_ctrl_map, sizeof(plain_map));
  memcpy(key_maps[8], dnalt_map, sizeof(plain_map));
  memcpy(key_maps[12], dnctrl_alt_map, sizeof(plain_map));

  mouse_dx=0; 
  mouse_dy=0; 
  mouse_buttons=0; 
  mouse_wait=NULL;

  misc_register(&apollo_mouse);

  /* program UpDownMode */

  while(!(sio01.sra_csra & 0x4));
  sio01.rhra_thra=0xff;

  while(!(sio01.sra_csra & 0x4));
  sio01.rhra_thra=0x1;

  request_irq(1, dn_keyb_int,0,NULL,NULL);
  
  /* enable receive int on DUART */
  sio01.isr_imr=3;

  return 0;

}

int dn_dummy_kbdrate(struct kbd_repeat *k) {

  printk("dn_dummy_kbdrate\n");

  return 0;

}