Lines Matching full:data
106 int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data)
111 memset(data, 0, sizeof(*data));
113 err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
117 if (data->n_attachments) {
118 data->attachments = malloc(sizeof(data->attachments[0]) *
119 data->n_attachments);
120 if (!data->attachments)
124 if (data->n_allowed_attachments) {
125 data->allowed_attachments =
126 malloc(sizeof(data->allowed_attachments[0]) *
127 data->n_allowed_attachments);
128 if (!data->allowed_attachments) {
134 if (data->custom_data_size) {
135 data->custom_data = malloc(data->custom_data_size);
136 if (!data->custom_data) {
142 err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data);
148 adf_free_device_data(data);
152 void adf_free_device_data(struct adf_device_data *data)
154 free(data->attachments);
155 free(data->allowed_attachments);
156 free(data->custom_data);
165 struct adf_post_config data;
167 memset(&data, 0, sizeof(data));
168 data.interfaces = interfaces;
169 data.n_interfaces = n_interfaces;
170 data.bufs = bufs;
171 data.n_bufs = n_bufs;
172 data.custom_data = custom_data;
173 data.custom_data_size = custom_data_size;
175 err = ioctl(dev->fd, ADF_POST_CONFIG, &data);
179 return (int)data.complete_fence;
186 struct adf_attachment_config data;
188 memset(&data, 0, sizeof(data));
189 data.overlay_engine = overlay_engine;
190 data.interface = interface;
192 err = ioctl(dev->fd, attach ? ADF_ATTACH : ADF_DETACH, &data);
222 struct adf_device_data data;
227 ret = adf_get_device_data(dev, &data);
232 for (i = 0; i < data.n_allowed_attachments; i++) {
233 if (data.allowed_attachments[i].overlay_engine != overlay_engine)
243 ids_ret[n] = data.allowed_attachments[i].interface;
250 adf_free_device_data(&data);
260 bool (*filter)(struct adf_interface_data *data, __u32 match),
275 struct adf_interface_data data;
276 ret = adf_get_interface_data(fd, &data);
281 if (!filter(&data, match))
305 static bool adf_interface_type_filter(struct adf_interface_data *data,
308 return data->type == (enum adf_interface_type)type;
319 static bool adf_interface_flags_filter(struct adf_interface_data *data,
322 return !!(data->flags & flag);
345 int adf_get_interface_data(int fd, struct adf_interface_data *data)
350 memset(data, 0, sizeof(*data));
352 err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
356 if (data->n_available_modes) {
357 data->available_modes = malloc(sizeof(data->available_modes[0]) *
358 data->n_available_modes);
359 if (!data->available_modes)
363 if (data->custom_data_size) {
364 data->custom_data = malloc(data->custom_data_size);
365 if (!data->custom_data) {
371 err = ioctl(fd, ADF_GET_INTERFACE_DATA, data);
377 adf_free_interface_data(data);
381 void adf_free_interface_data(struct adf_interface_data *data)
383 free(data->available_modes);
384 free(data->custom_data);
407 struct adf_simple_buffer_alloc data;
409 memset(&data, 0, sizeof(data));
410 data.w = w;
411 data.h = h;
412 data.format = format;
414 err = ioctl(fd, ADF_SIMPLE_BUFFER_ALLOC, &data);
418 *offset = data.offset;
419 *pitch = data.pitch;
420 return (int)data.fd;
428 struct adf_simple_post_config data;
430 memset(&data, 0, sizeof(data));
431 data.buf.overlay_engine = overlay_engine;
432 data.buf.w = w;
433 data.buf.h = h;
434 data.buf.format = format;
435 data.buf.fd[0] = buf_fd;
436 data.buf.offset[0] = offset;
437 data.buf.pitch[0] = pitch;
438 data.buf.n_planes = 1;
439 data.buf.acquire_fence = acquire_fence;
441 ret = ioctl(fd, ADF_SIMPLE_POST_CONFIG, &data);
445 return (int)data.complete_fence;
459 struct adf_device_data data;
464 ret = adf_get_device_data(dev, &data);
469 for (i = 0; i < data.n_allowed_attachments; i++) {
470 if (data.allowed_attachments[i].interface != interface)
480 ids_ret[n] = data.allowed_attachments[i].overlay_engine;
487 adf_free_device_data(&data);
497 bool (*filter)(struct adf_overlay_engine_data *data, void *cookie),
512 struct adf_overlay_engine_data data;
513 ret = adf_get_overlay_engine_data(fd, &data);
518 if (!filter(&data, cookie))
548 struct adf_overlay_engine_data *data, void *cookie)
552 for (i = 0; i < data->n_supported_formats; i++) {
555 if (data->supported_formats[i] == c->formats[j])
583 int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data)
588 memset(data, 0, sizeof(*data));
590 err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
594 if (data->n_supported_formats) {
595 data->supported_formats = malloc(sizeof(data->supported_formats[0]) *
596 data->n_supported_formats);
597 if (!data->supported_formats)
601 if (data->custom_data_size) {
602 data->custom_data = malloc(data->custom_data_size);
603 if (!data->custom_data) {
609 err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data);
615 adf_free_overlay_engine_data(data);
619 void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data)
621 free(data->supported_formats);
622 free(data->custom_data);
627 struct adf_overlay_engine_data data;
631 int err = adf_get_overlay_engine_data(fd, &data);
635 for (i = 0; i < data.n_supported_formats; i++) {
636 if (data.supported_formats[i] == format) {
642 adf_free_overlay_engine_data(&data);
648 struct adf_set_event data;
650 data.type = type;
651 data.enabled = enabled;
653 int err = ioctl(fd, ADF_SET_EVENT, &data);
664 uint8_t data[0];
683 ssize_t read_size = read(fd, &event_ret->data, data_size);
