Ejemplo n.º 1
0
void mouse_install()
{
	unsigned char cmm[] = { 0xE8, 0x03, 0xE6, 0xF3, 0x28, 0};

	// Ativando a porta auxiliar
	ps2_write(PS2_CTRL, 0xA8);

	printf("Resetando mouse... ");
	if (mouse_reset())
		printf("OK\n");

	mouse_command(ps2_init_string);

	printf("Mouse ID: %i\n", mouse_getid());

	mouse_setrate(10);

	mouse_command(cmm);

	mouse_enable();
}
Ejemplo n.º 2
0
void process_stddev(void)
{
    struct stddev_cmd stddev_msg;
    struct stddev_res res;
    struct stddev_devtype_res *type_res = NULL;
    struct stddev_ver_res *ver_res = NULL;
    struct stddev_ioctl_cmd *ioctl = NULL;
    struct key_suscription *s = NULL;
    int i = 0, sender_id;  

    while(get_msg_count(CSL_STDDEV_PORT) > 0)
    {
            get_msg(CSL_STDDEV_PORT, &stddev_msg, &sender_id);

            res.logic_deviceid = -1;
            res.command = stddev_msg.command;
            res.msg_id = stddev_msg.msg_id;

            switch(stddev_msg.command)
            {
                    case STDDEV_GET_DEVICETYPE:
                            type_res = (struct stddev_devtype_res*)&res;
                            type_res->dev_type = STDDEV_CHAR;
                            type_res->ret = STDDEV_OK;
                            type_res->msg_id = stddev_msg.msg_id;
                            break;
                    case STDDEV_VER:
                            ver_res = (struct stddev_ver_res*)&res;
                            ver_res->ret = STDDEV_OK;
                            ver_res->ver = STDDEV_VERSION;
                            ver_res->msg_id = stddev_msg.msg_id;
                            break;
                    case STDDEV_GET_DEVICE:
                    case STDDEV_GET_DEVICEX:
                            res.logic_deviceid = stddev_msg.padding0;
                            res.msg_id = stddev_msg.msg_id;
                            res.ret = STDDEV_OK;
                            break;
                    case STDDEV_FREE_DEVICE:
                            res.logic_deviceid = stddev_msg.padding0;
                            res.msg_id = stddev_msg.msg_id;
                            res.ret = STDDEV_OK;
                            break;
                    case STDDEV_IOCTL:
                            ioctl = (struct stddev_ioctl_cmd*)&stddev_msg;
                            res.ret = STDDEV_ERR;
                            res.logic_deviceid = ioctl->logic_deviceid;
               
                            //if(!check_ownership(ioctl->logic_deviceid, sender_id)) break;
                            if(res.logic_deviceid >= NUM_VIRTUAL)
                                    string_print("CONS: ASSERT 1",0,7);

                            ((struct stddev_ioctrl_res *)&res)->dev_error = -1;
                            switch(ioctl->request)
                            {
                                    case CSL_IO_DISABLE_ECHO:
                                            i = 0;
                                            while(i < t[res.logic_deviceid].owners)
                                            {
                                                    if(t[res.logic_deviceid].ownerid[i] == sender_id)
                                                    {
                                                            t[res.logic_deviceid].force_echo[i] = CSL_FORCE_NOECHO;
                                                            break;
                                                    }
                                                    i++;
                                            }
                                            res.ret = STDDEV_OK;
                                            break;
                                    case CSL_IO_COMMAND_ECHO:
                                            i = 0;
                                            while(i < t[res.logic_deviceid].owners)
                                            {
                                                    if(t[res.logic_deviceid].ownerid[i] == sender_id)
                                                    {
                                                            t[res.logic_deviceid].force_echo[i] = CSL_FORCE_NONE;
                                                            break;
                                                    }
                                                    i++;
                                            }
                                            res.ret = STDDEV_OK;
                                            break;
                                    case CSL_IO_ENABLE_ECHO:
                                            i = 0;
                                            while(i < t[res.logic_deviceid].owners)
                                            {
                                                    if(t[res.logic_deviceid].ownerid[i] == sender_id)
                                                    {
                                                            t[res.logic_deviceid].force_echo[i] = CSL_FORCE_ECHO;
                                                            break;
                                                    }
                                                    i++;
                                            }
                                            res.ret = STDDEV_OK;
                                            break;
                                    case CSL_IO_SWITCH:
                                            vt_switch(ioctl->logic_deviceid);
                                            res.ret = STDDEV_OK;
                                            break;
                                    case CSL_IO_SETATT:
                                            t[ioctl->logic_deviceid].attribute = (char)ioctl->param;
                                            res.ret = STDDEV_OK;
                                            break;
                                    case CSL_IO_SETSIGNALPORT:
                                            s = get_suscription(sender_id, ioctl->logic_deviceid);
                    if(s)
                    {
                                                s->port = ioctl->param;
                                                res.ret = STDDEV_OK;
                    }
                    else
                    {
                            res.ret = STDDEV_ERR;
                    }
                                            break;
                case CSL_IO_SIGNAL:
                                            s = get_suscription(sender_id, ioctl->logic_deviceid);
                                            if(s == NULL || s->susc != MAX_SUSCRIPTIONS)
                                            {
                                                    res.ret = STDDEV_OK;
                                                    s->keycodes[s->susc] = (char)ioctl->param;
                                                    s->susc++;
                                            }
                    else
                    {
                            res.ret = STDDEV_ERR;
                    }
                                            break;
                                    case CSL_IO_USIGNAL:
                                            if(remove_suscription(sender_id, ioctl->logic_deviceid))
                                                    res.ret = STDDEV_ERR;
                                            else
                                                    res.ret = STDDEV_OK;
                                            break;
                case CSL_IO_MSIGNAL:
                    {
                        for(i = 0; i < MAX_MOUSE_SUSCRIPTIONS; i++)
                        {
                            if(mouse_suscriptions[i] == -1)
                                break;
                        }
                        if(i == MAX_MOUSE_SUSCRIPTIONS)
                        {
                            res.ret = STDDEV_ERR;
                        }
                        else
                        {
                            mouse_suscriptions[i] = sender_id;
                            mouse_suscriptions_ports[i] = 0;
                            msuscs++;
                            res.ret = STDDEV_OK;
                        }
                    }
                                            break;
                case CSL_IO_UMSIGNAL:
                    {
                        for(i = 0; i < MAX_MOUSE_SUSCRIPTIONS; i++)
                        {
                            if(mouse_suscriptions[i] == sender_id)
                                break;
                        }
                        if(i == MAX_MOUSE_SUSCRIPTIONS)
                        {
                            res.ret = STDDEV_ERR;
                        }
                        else
                        {
                            mouse_suscriptions[i] = -1;
                            msuscs--;
                            res.ret = STDDEV_OK;
                        }
                    }
                                            break;
                case CSL_IO_SETMSIGNALPORT:
                                            {
                        for(i = 0; i < MAX_MOUSE_SUSCRIPTIONS; i++)
                        {
                            if(mouse_suscriptions[i] == sender_id)
                                break;
                        }
                        if(i == MAX_MOUSE_SUSCRIPTIONS)
                        {
                            res.ret = STDDEV_ERR;
                        }
                        else
                        {
                            mouse_suscriptions_ports[i] = ioctl->param;
                            res.ret = STDDEV_OK;
                        }
                    }
                                            break;
                case CSL_MOUSE_ENABLE:
                    mouse_enable(ioctl->param);
                                            res.ret = STDDEV_OK;
                    break;
                            }
                    break;
            }
            send_msg(sender_id, stddev_msg.ret_port, &res);
    }
}