static bool_t keyboard_probe(struct input * input)
{
	u32_t divisor;
	u64_t kclk;
	u8_t data;

	if(! clk_get_rate("kclk", &kclk))
	{
		LOG_E("can't get the clock of 'kclk'");
		return FALSE;
	}

	/* set keyboard's clock divisor */
	divisor = (u32_t)(div64(kclk, 8000000) - 1);
	writeb(REALVIEW_KEYBOARD_CLKDIV, divisor);

	/* enable keyboard controller */
	writeb(REALVIEW_KEYBOARD_CR, REALVIEW_KEYBOARD_CR_EN);

	/* clear a receive buffer */
	kmi_read(&data);

	/* reset keyboard, and wait ack and pass/fail code */
	if(! kmi_write(0xff) )
		return FALSE;
	if(! kmi_read(&data))
		return FALSE;
	if(data != 0xaa)
		return FALSE;

	/* set keyboard's typematic rate/delay */
	kmi_write(0xf3);
	/* 10.9pcs, 500ms */
	kmi_write(0x2b);

	/* scan code set 2 */
	kmi_write(0xf0);
	kmi_write(0x02);

	/* set all keys typematic/make/break */
	kmi_write(0xfa);

	/* set keyboard's number lock, caps lock, and scroll lock */
	kmi_write(0xed);
	kmi_write(0x02);

	if(!request_irq("KMI0", keyboard_interrupt))
	{
		LOG_E("can't request irq 'KMI0'");
		writeb(REALVIEW_KEYBOARD_CR, 0);
		return FALSE;
	}

	/* re-enables keyboard */
	writeb(REALVIEW_KEYBOARD_CR, REALVIEW_KEYBOARD_CR_EN | REALVIEW_KEYBOARD_CR_RXINTREN);

	return TRUE;
}
Exemple #2
0
static void input_init(struct input_t * input)
{
	struct resource_t * res = (struct resource_t *)input->priv;
	struct realview_keyboard_data_t * dat = (struct realview_keyboard_data_t *)res->data;
	u32_t divisor;
	u64_t kclk;
	u8_t value;

	clk_enable("kclk");
	kclk = clk_get_rate("kclk");
	if(!kclk)
		return;

	/* Set keyboard's clock divisor */
	divisor = (u32_t)(kclk / 8000000) - 1;
	write8(phys_to_virt(dat->regbase + KEYBOARD_CLKDIV), divisor);

	/* Enable keyboard controller */
	write8(phys_to_virt(dat->regbase + KEYBOARD_CR), KEYBOARD_CR_EN);

	/* Clear a receive buffer */
	kmi_read(dat, &value);

	/* Reset keyboard, and wait ack and pass/fail code */
	if(! kmi_write(dat, 0xff) )
		return;
	if(! kmi_read(dat, &value))
		return;
	if(value != 0xaa)
		return;

	/* Set keyboard's typematic rate/delay */
	kmi_write(dat, 0xf3);
	/* 10.9pcs, 500ms */
	kmi_write(dat, 0x2b);

	/* Scan code set 2 */
	kmi_write(dat, 0xf0);
	kmi_write(dat, 0x02);

	/* Set all keys typematic/make/break */
	kmi_write(dat, 0xfa);

	/* Set keyboard's number lock, caps lock, and scroll lock */
	kmi_write(dat, 0xed);
	kmi_write(dat, 0x02);

	if(!request_irq(REALVIEW_IRQ_KMI0, keyboard_interrupt, IRQ_TYPE_NONE, input))
	{
		write8(phys_to_virt(dat->regbase + KEYBOARD_CR), 0);
		return;
	}

	/* Re-enables keyboard */
	write8(phys_to_virt(dat->regbase + KEYBOARD_CR), KEYBOARD_CR_EN | KEYBOARD_CR_RXINTREN);
}
Exemple #3
0
int main(void)
{
    int delay;
    int x, y;
    int key_pressed = 0;
    int last_key_pressed = 0;
    enum ps2_state { idle, got_prefix, got_release } key_state = idle;
    
    clear_screen();
    init_lcd();
    init_kmi();

    x = 30; y = 30;
    do {
        uint32 key_code;

        fill_rect(x * 3, y * 3, 2, 2, 0xffff);

        last_key_pressed = 0;

        for (delay = 0; delay < 0x80000; ++delay) {
            key_code = kmi_read();

            switch (key_code) {
            case 0: break;
            case KEY_PREFIX: key_state = got_prefix; break;
            case KEY_RELEASE: key_state = got_release; break;
            default:
                if (key_state == got_release) {
                    key_pressed = 0;
                } else {
                    last_key_pressed = key_pressed = key_code;
                }
                key_state = idle;
                break;
            }
        }

        if (last_key_pressed == 0) {
            last_key_pressed = key_pressed;
        }

        fill_rect(x * 3, y * 3, 2, 2, 0x7777);
        switch (last_key_pressed) {
        case KEY_LEFT:  case KEY_4: x -= 1; break;
        case KEY_RIGHT: case KEY_6: x += 1; break;
        case KEY_UP:    case KEY_2: y -= 1; break;
        case KEY_DOWN:  case KEY_8: y += 1; break;
        }

    } while (1);
}
static bool_t mouse_probe(struct input * input)
{
	u32_t divisor;
	u64_t kclk;
	u8_t data;

	if(! clk_get_rate("kclk", &kclk))
	{
		LOG_E("can't get the clock of 'kclk'");
		return FALSE;
	}

	/* set mouse's clock divisor */
	divisor = (u32_t)(div64(kclk, 8000000) - 1);
	writeb(REALVIEW_MOUSE_CLKDIV, divisor);

	/* enable mouse controller */
	writeb(REALVIEW_MOUSE_CR, REALVIEW_MOUSE_CR_EN);

	/* reset mouse, and wait ack and pass/fail code */
	if(! kmi_write(0xff) )
		return FALSE;
	if(! kmi_read(&data))
		return FALSE;
	if(data != 0xaa)
		return FALSE;

	/* enable scroll wheel */
	kmi_write(0xf3);
	kmi_write(200);

	kmi_write(0xf3);
	kmi_write(100);

	kmi_write(0xf3);
	kmi_write(80);

	kmi_write(0xf2);
	kmi_read(&data);
	kmi_read(&data);

	/* set sample rate, 100 samples/sec */
	kmi_write(0xf3);
	kmi_write(100);

	/* set resolution, 4 counts per mm, 1:1 scaling */
	kmi_write(0xe8);
	kmi_write(0x02);
	kmi_write(0xe6);

	/* enable data reporting */
	kmi_write(0xf4);

	/* clear a receive buffer */
	kmi_read(&data);
	kmi_read(&data);
	kmi_read(&data);
	kmi_read(&data);

	if(!request_irq("KMI1", mouse_interrupt))
	{
		LOG_E("can't request irq 'KMI1'");
		writeb(REALVIEW_MOUSE_CR, 0);
		return FALSE;
	}

	/* re-enables mouse */
	writeb(REALVIEW_MOUSE_CR, REALVIEW_MOUSE_CR_EN | REALVIEW_MOUSE_CR_RXINTREN);

	return TRUE;
}
Exemple #5
0
int rt_hw_mouse_init(void)
{
    rt_uint8_t value;
    rt_uint32_t id;
    struct mouse_pl050_pdata_t *pdat;
    virtual_addr_t virt = MOUSE_ADDRESS;
    int irq = MOUSE_IRQ_NUM;

    id = (((read32(virt + 0xfec) & 0xff) << 24) |
                ((read32(virt + 0xfe8) & 0xff) << 16) |
                ((read32(virt + 0xfe4) & 0xff) <<  8) |
                ((read32(virt + 0xfe0) & 0xff) <<  0));
    
    if(((id >> 12) & 0xff) != 0x41 || (id & 0xfff) != 0x050)
    {
        dbg_log(DBG_ERROR, "read id fail id:0x%08x\n", id);
        return RT_ERROR;
    }

    pdat = rt_malloc(sizeof(struct mouse_pl050_pdata_t));
    if(!pdat)
    {
        dbg_log(DBG_ERROR, "malloc memory\n", id);
        return RT_ERROR;
    }
    rt_memset(pdat, 0, sizeof(struct mouse_pl050_pdata_t));

    pdat->virt = virt;
    pdat->irq = irq;
    pdat->xmax = MOUSE_XMAX;
    pdat->ymax = MOUSE_YMAX;
    pdat->xpos = pdat->xmax / 2;
    pdat->ypos = pdat->ymax / 2;
    pdat->packet[0] = 0;
    pdat->packet[1] = 0;
    pdat->packet[2] = 0;
    pdat->packet[3] = 0;
    pdat->index = 0;
    pdat->obtn = 0;

    write8(pdat->virt + MOUSE_CLKDIV, 0);
    write8(pdat->virt + MOUSE_CR, (1 << 2));
    kmi_write(pdat, 0xff);
    kmi_read(pdat, &value);
    kmi_write(pdat, 0xf3);
    kmi_write(pdat, 200);
    kmi_write(pdat, 0xf3);
    kmi_write(pdat, 100);
    kmi_write(pdat, 0xf3);
    kmi_write(pdat, 80);
    kmi_write(pdat, 0xf2);
    kmi_read(pdat, &value);
    kmi_read(pdat, &value);
    kmi_write(pdat, 0xf3);
    kmi_write(pdat, 100);
    kmi_write(pdat, 0xe8);
    kmi_write(pdat, 0x02);
    kmi_write(pdat, 0xe6);
    kmi_write(pdat, 0xf4);
    kmi_read(pdat, &value);
    kmi_read(pdat, &value);
    kmi_read(pdat, &value);
    kmi_read(pdat, &value);
    write8(pdat->virt + MOUSE_CR, (1 << 2) | (1 << 4));

    rt_hw_interrupt_install(pdat->irq, mouse_pl050_interrupt, (void *)pdat, "mouse");
    rt_hw_interrupt_umask(pdat->irq);

    return RT_EOK;
}