Example #1
0
int dthread_port_send_dterm(dthread_t* thr, dthread_t* source, 
			    ErlDrvTermData target, dterm_t* p)
{
    return dthread_port_send_term(thr, source, target,
				  dterm_data(p),
				  dterm_used_size(p));
}
Example #2
0
static void inpevt_ready_input(ErlDrvData drv_data, ErlDrvEvent event)
{
    IEContext* ctx = 0;
    struct input_event buf[32];
    ssize_t rd_res = 0;

    ctx = (IEContext*) drv_data;

    if (ctx->mDescriptor == -1) {
        return;
    }


    while((rd_res = read(ctx->mDescriptor, (char*) buf, sizeof(buf))) > 0) {
        int i = 0;
        for (i = 0; i < rd_res / sizeof(buf[0]); ++i) {
            dterm_t dt;
            dterm_mark_t ev_mark;

            dterm_init(&dt);
            dterm_tuple_begin(&dt, &ev_mark);
            dterm_atom(&dt, ie_input_event);
            dterm_port(&dt, ctx->mDport);
            dterm_int(&dt, buf[i].time.tv_sec);
            dterm_int(&dt, buf[i].time.tv_usec);
            dterm_atom(&dt, *type_atoms[buf[i].type].atom);

            if (type_atoms[buf[i].type].code)
                dterm_atom(&dt, *type_atoms[buf[i].type].code[buf[i].code]);
            else
                dterm_atom(&dt, ie_unknown);

            dterm_int(&dt, buf[i].code);

            dterm_int(&dt, buf[i].value);

            dterm_tuple_end(&dt, &ev_mark);

            driver_output_term(ctx->mPort,
                               dterm_data(&dt),
                               dterm_used_size(&dt));

            dterm_finish(&dt);
        }
    }
    return;
}
Example #3
0
// send {Ref, ok}
int dthread_port_send_ok(dthread_t* thr, dthread_t* source, 
			 ErlDrvTermData target, ErlDrvTermData ref)
{
    dterm_t t;
    dterm_mark_t m;
    int r;

    dterm_init(&t);
    dterm_tuple_begin(&t, &m); {
	dterm_int(&t, ref);
	dterm_atom(&t, am_ok);
    }
    dterm_tuple_end(&t, &m);
    
    r = dthread_port_send_term(thr, source, target,
			       dterm_data(&t), dterm_used_size(&t));
    dterm_finish(&t);
    return r;
}
Example #4
0
static unsigned char send_device_info(IEContext* ctx, unsigned int reply_id)
{
    dterm_mark_t msg;
    dterm_t dt;
    int len = 0;
    char name[256];
    char topology[256];
    char uniq_id[256];

    struct input_id id;

    // Get device id.
    if (ioctl(ctx->mDescriptor, EVIOCGID, &id) < 0)
    {
        return IEDRV_RES_IO_ERROR;
    }

    if ((len = ioctl(ctx->mDescriptor, EVIOCGNAME(sizeof(name) - 1), name)) < 0) {
        return IEDRV_RES_IO_ERROR;
    }
    name[len] = 0;

    if ((len = ioctl(ctx->mDescriptor, EVIOCGPHYS(sizeof(topology) - 1), topology)) < 0) {
        return IEDRV_RES_IO_ERROR;
    }
    topology[len] = 0;

    if ((len = ioctl(ctx->mDescriptor, EVIOCGUNIQ(sizeof(uniq_id) - 1), uniq_id)) < 0)
        uniq_id[0] = 0;

    uniq_id[len] = 0;

    dterm_init(&dt);

    dterm_tuple_begin(&dt, &msg); {
        dterm_mark_t prop;

        dterm_atom(&dt, ie_device_info);
        dterm_port(&dt, ctx->mDport);
        dterm_int(&dt, reply_id);


        //
        // Setup { id, Bustype, Vendor, Product, Version, Name}
        //
        dterm_tuple_begin(&dt, &prop); {
            dterm_atom(&dt, ie_drv_dev_id);
            dterm_string(&dt, uniq_id, strlen(uniq_id));
            dterm_string(&dt, name, strlen(name));
            dterm_atom(&dt, *bus_atoms[id.bustype]);
            dterm_int(&dt, id.vendor);
            dterm_int(&dt, id.product);
            dterm_int(&dt, id.version);
            dterm_string(&dt, topology, strlen(topology));

            //
            // Setup [{ capability, [ { Cap, [X] }, { Cap, [Y] }, ...}, ...]
            //
            add_cap(&dt,  ctx->mDescriptor);
            dterm_tuple_end(&dt, &prop);
        }
    }
    dterm_tuple_end(&dt, &msg);
    driver_output_term(ctx->mPort, dterm_data(&dt), dterm_used_size(&dt));
    dterm_finish(&dt);


    return IEDRV_RES_OK;
}