36
36
pcilib_event_description_t *events = model_info->events;
38
38
for (i = 0; events[i].name; i++) {
39
if (!strcasecmp(events[i].name, event)) return (1<<i);
39
if (!strcasecmp(events[i].name, event)) return events[i].evid;
42
42
return (pcilib_event_t)-1;
45
pcilib_event_data_type_t pcilib_find_event_data_type(pcilib_t *ctx, pcilib_event_t event, const char *data_type) {
47
pcilib_register_bank_t res;
50
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
51
pcilib_event_data_type_description_t *data_types = model_info->data_types;
53
for (i = 0; data_types[i].name; i++) {
54
if ((data_types[i].evid&event)&&(!strcasecmp(data_types[i].name, data_type))) return data_types[i].data_type;
57
return (pcilib_event_data_type_t)-1;
60
int pcilib_init_event_engine(pcilib_t *ctx) {
61
pcilib_event_api_description_t *api;
62
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
64
api = model_info->event_api;
66
// api = pcilib_model[model].event_api;
67
if ((api)&&(api->init)) {
68
ctx->event_ctx = api->init(ctx);
70
ctx->event_ctx->pcilib = ctx;
46
77
int pcilib_reset(pcilib_t *ctx) {
47
78
pcilib_event_api_description_t *api;
63
int pcilib_start(pcilib_t *ctx, pcilib_event_t event_mask, void *callback, void *user) {
94
int pcilib_configure_rawdata_callback(pcilib_t *ctx, pcilib_event_rawdata_callback_t callback, void *user) {
95
pcilib_event_api_description_t *api;
97
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
99
api = model_info->event_api;
101
pcilib_error("Event API is not supported by the selected model");
102
return PCILIB_ERROR_NOTSUPPORTED;
105
ctx->event_ctx->params.rawdata.callback = callback;
106
ctx->event_ctx->params.rawdata.user = user;
111
int pcilib_configure_autostop(pcilib_t *ctx, size_t max_events, pcilib_timeout_t duration) {
112
pcilib_event_api_description_t *api;
114
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
116
api = model_info->event_api;
118
pcilib_error("Event API is not supported by the selected model");
119
return PCILIB_ERROR_NOTSUPPORTED;
122
ctx->event_ctx->params.autostop.max_events = max_events;
123
ctx->event_ctx->params.autostop.duration = duration;
128
int pcilib_start(pcilib_t *ctx, pcilib_event_t event_mask, pcilib_event_flags_t flags) {
64
129
pcilib_event_api_description_t *api;
66
131
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
75
return api->start(ctx->event_ctx, event_mask, callback, user);
140
return api->start(ctx->event_ctx, event_mask, flags);
80
int pcilib_stop(pcilib_t *ctx) {
145
int pcilib_stop(pcilib_t *ctx, pcilib_event_flags_t flags) {
81
146
pcilib_event_api_description_t *api;
83
148
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
92
return api->stop(ctx->event_ctx);
157
return api->stop(ctx->event_ctx, flags);
97
pcilib_event_id_t pcilib_get_next_event(pcilib_t *ctx, pcilib_event_t event_mask, pcilib_timeout_t timeout) {
98
pcilib_event_api_description_t *api;
162
int pcilib_stream(pcilib_t *ctx, pcilib_event_callback_t callback, void *user) {
163
pcilib_event_api_description_t *api;
165
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
167
api = model_info->event_api;
169
pcilib_error("Event API is not supported by the selected model");
170
return PCILIB_ERROR_NOTSUPPORTED;
174
return api->stream(ctx->event_ctx, callback, user);
176
if (api->next_event) {
177
pcilib_error("Streaming using next_event API is not implemented yet");
180
pcilib_error("Event enumeration is not suppored by API");
181
return PCILIB_ERROR_NOTSUPPORTED;
185
pcilib_event_id_t event_id;
186
pcilib_event_info_t *info;
187
} pcilib_return_event_callback_context_t;
189
static int pcilib_return_event_callback(pcilib_event_id_t event_id, pcilib_event_info_t *info, void *user) {
190
pcilib_return_event_callback_context_t *ctx = (pcilib_return_event_callback_context_t*)user;
191
ctx->event_id = event_id;
196
int pcilib_get_next_event(pcilib_t *ctx, pcilib_timeout_t timeout, pcilib_event_id_t *evid, pcilib_event_info_t **info) {
198
pcilib_event_api_description_t *api;
199
// pcilib_return_event_callback_context_t user;
100
201
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
108
209
if (api->next_event)
109
return api->next_event(ctx->event_ctx, event_mask, timeout);
210
return api->next_event(ctx->event_ctx, timeout, evid, info);
214
err = api->stream(ctx->event_ctx, 1, timeout, pcilib_return_event_callback, &user);
217
if (evid) *evid = user->event_id;
218
if (info) *info = user->info;
111
224
pcilib_error("Event enumeration is not suppored by API");
112
return PCILIB_EVENT_ID_INVALID;
225
return PCILIB_ERROR_NOTSUPPORTED;
115
228
int pcilib_trigger(pcilib_t *ctx, pcilib_event_t event, size_t trigger_size, void *trigger_data) {
143
256
if (api->get_data)
144
return api->get_data(ctx->event_ctx, event_id, data_type, arg_size, arg, size);
257
return api->get_data(ctx->event_ctx, event_id, data_type, arg_size, arg, size, NULL);
262
int pcilib_copy_data_with_argument(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, size_t arg_size, void *arg, size_t size, void *buf, size_t *retsize) {
264
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
266
pcilib_event_api_description_t *api = model_info->event_api;
268
pcilib_error("Event API is not supported by the selected model");
269
return PCILIB_ERROR_NOTSUPPORTED;
273
res = api->get_data(ctx->event_ctx, event_id, data_type, arg_size, arg, &size, buf);
274
if (!res) return PCILIB_ERROR_FAILED;
276
if (retsize) *retsize = size;
280
return PCILIB_ERROR_NOTSUPPORTED;
149
284
void *pcilib_get_data(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, size_t *size) {
150
285
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
158
293
if (api->get_data)
159
return api->get_data(ctx->event_ctx, event_id, data_type, 0, NULL, size);
294
return api->get_data(ctx->event_ctx, event_id, data_type, 0, NULL, size, NULL);
164
int pcilib_return_data(pcilib_t *ctx, pcilib_event_id_t event_id) {
299
int pcilib_copy_data(pcilib_t *ctx, pcilib_event_id_t event_id, pcilib_event_data_type_t data_type, size_t size, void *buf, size_t *ret_size) {
301
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
303
pcilib_event_api_description_t *api = model_info->event_api;
305
pcilib_error("Event API is not supported by the selected model");
306
return PCILIB_ERROR_NOTSUPPORTED;
310
res = api->get_data(ctx->event_ctx, event_id, data_type, 0, NULL, &size, buf);
311
if (!res) return PCILIB_ERROR_FAILED;
313
if (ret_size) *ret_size = size;
317
return PCILIB_ERROR_NOTSUPPORTED;
320
int pcilib_return_data(pcilib_t *ctx, pcilib_event_id_t event_id, void *data) {
165
321
pcilib_model_description_t *model_info = pcilib_get_model_description(ctx);
167
323
pcilib_event_api_description_t *api = model_info->event_api;
218
375
memcpy(*(user->data), data, size);
220
err = pcilib_return_data(user->ctx, event_id);
377
err = pcilib_return_data(user->ctx, event_id, data);
223
380
free(*(user->data));
233
390
int pcilib_grab(pcilib_t *ctx, pcilib_event_t event_mask, size_t *size, void **data, pcilib_timeout_t timeout) {
235
392
struct timespec ts;
393
pcilib_event_id_t eid;
237
395
pcilib_grab_callback_user_data_t user = {ctx, size, data};
239
err = pcilib_start(ctx, event_mask, pcilib_grab_callback, &user);
397
err = pcilib_start(ctx, event_mask, PCILIB_EVENT_FLAGS_DEFAULT);
398
if (!err) err = pcilib_trigger(ctx, event_mask, 0, NULL);
242
ts.tv_sec = timeout / 1000000;
243
ts.tv_nsec = 1000 * (timeout % 1000000);
244
nanosleep(&ts, NULL);
245
} else err = pcilib_trigger(ctx, event_mask, 0, NULL);
400
err = pcilib_get_next_event(ctx, timeout, &eid, NULL);
401
if (!err) pcilib_grab_callback(event_mask, eid, &user);
403
pcilib_stop(ctx, PCILIB_EVENT_FLAGS_DEFAULT);