#endif
/* drm backend functions (display) */
-tdm_error drm_display_get_capability(tdm_backend_data *bdata, tdm_caps_display *caps);
-tdm_error drm_display_get_pp_capability(tdm_backend_data *bdata, tdm_caps_pp *caps);
+tdm_error drm_display_get_capability(tdm_backend_data *bdata, tdm_caps_display *caps);
+tdm_error drm_display_get_pp_capability(tdm_backend_data *bdata, tdm_caps_pp *caps);
tdm_output** drm_display_get_outputs(tdm_backend_data *bdata, int *count, tdm_error *error);
-tdm_error drm_display_get_fd(tdm_backend_data *bdata, int *fd);
-tdm_error drm_display_handle_events(tdm_backend_data *bdata);
-tdm_pp* drm_display_create_pp(tdm_backend_data *bdata, tdm_error *error);
-tdm_error drm_output_get_capability(tdm_output *output, tdm_caps_output *caps);
+tdm_error drm_display_get_fd(tdm_backend_data *bdata, int *fd);
+tdm_error drm_display_handle_events(tdm_backend_data *bdata);
+tdm_pp* drm_display_create_pp(tdm_backend_data *bdata, tdm_error *error);
+tdm_error drm_output_get_capability(tdm_output *output, tdm_caps_output *caps);
tdm_layer** drm_output_get_layers(tdm_output *output, int *count, tdm_error *error);
-tdm_error drm_output_set_property(tdm_output *output, unsigned int id, tdm_value value);
-tdm_error drm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value);
-tdm_error drm_output_wait_vblank(tdm_output *output, int interval, int sync, void *user_data);
-tdm_error drm_output_set_vblank_handler(tdm_output *output, tdm_output_vblank_handler func);
-tdm_error drm_output_commit(tdm_output *output, int sync, void *user_data);
-tdm_error drm_output_set_commit_handler(tdm_output *output, tdm_output_commit_handler func);
-tdm_error drm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value);
-tdm_error drm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value);
-tdm_error drm_output_set_mode(tdm_output *output, const tdm_output_mode *mode);
-tdm_error drm_output_get_mode(tdm_output *output, const tdm_output_mode **mode);
-tdm_error drm_output_set_status_handler(tdm_output *output, tdm_output_status_handler func, void *user_data);
-tdm_error drm_layer_get_capability(tdm_layer *layer, tdm_caps_layer *caps);
-tdm_error drm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value);
-tdm_error drm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value);
-tdm_error drm_layer_set_info(tdm_layer *layer, tdm_info_layer *info);
-tdm_error drm_layer_get_info(tdm_layer *layer, tdm_info_layer *info);
-tdm_error drm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer);
-tdm_error drm_layer_unset_buffer(tdm_layer *layer);
-void drm_pp_destroy(tdm_pp *pp);
-tdm_error drm_pp_set_info(tdm_pp *pp, tdm_info_pp *info);
-tdm_error drm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst);
-tdm_error drm_pp_commit(tdm_pp *pp);
-tdm_error drm_pp_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func, void *user_data);
+tdm_error drm_output_set_property(tdm_output *output, unsigned int id, tdm_value value);
+tdm_error drm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value);
+tdm_error drm_output_wait_vblank(tdm_output *output, int interval, int sync, void *user_data);
+tdm_error drm_output_set_vblank_handler(tdm_output *output, tdm_output_vblank_handler func);
+tdm_error drm_output_commit(tdm_output *output, int sync, void *user_data);
+tdm_error drm_output_set_commit_handler(tdm_output *output, tdm_output_commit_handler func);
+tdm_error drm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value);
+tdm_error drm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value);
+tdm_error drm_output_set_mode(tdm_output *output, const tdm_output_mode *mode);
+tdm_error drm_output_get_mode(tdm_output *output, const tdm_output_mode **mode);
+tdm_error drm_output_set_status_handler(tdm_output *output, tdm_output_status_handler func, void *user_data);
+tdm_error drm_layer_get_capability(tdm_layer *layer, tdm_caps_layer *caps);
+tdm_error drm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value);
+tdm_error drm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value);
+tdm_error drm_layer_set_info(tdm_layer *layer, tdm_info_layer *info);
+tdm_error drm_layer_get_info(tdm_layer *layer, tdm_info_layer *info);
+tdm_error drm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer);
+tdm_error drm_layer_unset_buffer(tdm_layer *layer);
+void drm_pp_destroy(tdm_pp *pp);
+tdm_error drm_pp_set_info(tdm_pp *pp, tdm_info_pp *info);
+tdm_error drm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst);
+tdm_error drm_pp_commit(tdm_pp *pp);
+tdm_error drm_pp_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func, void *user_data);
/* drm module internal macros, structures, functions */
#define NEVER_GET_HERE() TDM_ERR("** NEVER GET HERE **")
-#define C(b,m) (((b) >> (m)) & 0xFF)
-#define B(c,s) ((((unsigned int)(c)) & 0xff) << (s))
-#define FOURCC(a,b,c,d) (B(d,24) | B(c,16) | B(b,8) | B(a,0))
-#define FOURCC_STR(id) C(id,0), C(id,8), C(id,16), C(id,24)
+#define C(b, m) (((b) >> (m)) & 0xFF)
+#define B(c, s) ((((unsigned int)(c)) & 0xff) << (s))
+#define FOURCC(a, b, c, d) (B(d, 24) | B(c, 16) | B(b, 8) | B(a, 0))
+#define FOURCC_STR(id) C(id, 0), C(id, 8), C(id, 16), C(id, 24)
-#define IS_RGB(format) (format == TBM_FORMAT_XRGB8888 || format == TBM_FORMAT_ARGB8888 || \
- format == TBM_FORMAT_XBGR8888 || format == TBM_FORMAT_ABGR8888)
+#define IS_RGB(format) (format == TBM_FORMAT_XRGB8888 || format == TBM_FORMAT_ARGB8888 || \
+ format == TBM_FORMAT_XBGR8888 || format == TBM_FORMAT_ABGR8888)
#define CLEAR(x) memset(&(x), 0, sizeof(x))
-#define MAX(a,b) (((a) > (b)) ? (a) : (b))
-#define MIN(a,b) (((a) < (b)) ? (a) : (b))
-#define SWAP(a, b) ({int t; t = a; a = b; b = t;})
-#define ROUNDUP(x) (ceil (floor ((float)(height) / 4)))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#define SWAP(a, b) ({int t; t = a; a = b; b = t; })
+#define ROUNDUP(x) (ceil(floor((float)(height) / 4)))
-#define ALIGN_TO_16B(x) ((((x) + (1 << 4) - 1) >> 4) << 4)
-#define ALIGN_TO_32B(x) ((((x) + (1 << 5) - 1) >> 5) << 5)
+#define ALIGN_TO_16B(x) ((((x) + (1 << 4) - 1) >> 4) << 4)
+#define ALIGN_TO_32B(x) ((((x) + (1 << 5) - 1) >> 5) << 5)
#define ALIGN_TO_128B(x) ((((x) + (1 << 7) - 1) >> 7) << 7)
-#define ALIGN_TO_2KB(x) ((((x) + (1 << 11) - 1) >> 11) << 11)
-#define ALIGN_TO_8KB(x) ((((x) + (1 << 13) - 1) >> 13) << 13)
+#define ALIGN_TO_2KB(x) ((((x) + (1 << 11) - 1) >> 11) << 11)
+#define ALIGN_TO_8KB(x) ((((x) + (1 << 13) - 1) >> 13) << 13)
#define ALIGN_TO_64KB(x) ((((x) + (1 << 16) - 1) >> 16) << 16)
#define RETURN_VAL_IF_FAIL(cond, val) {\
- if (!(cond)) {\
- TDM_ERR("'%s' failed", #cond);\
- return val;\
- }\
+ if (!(cond)) {\
+ TDM_ERR("'%s' failed", #cond);\
+ return val;\
+ } \
}
#define GOTO_IF_FAIL(cond, val) {\
- if (!(cond)) {\
- TDM_ERR("'%s' failed", #cond);\
- goto val;\
- }\
+ if (!(cond)) {\
+ TDM_ERR("'%s' failed", #cond);\
+ goto val;\
+ } \
}
-typedef struct _tdm_drm_data
-{
- tdm_display *dpy;
+typedef struct _tdm_drm_data {
+ tdm_display *dpy;
- int drm_fd;
+ int drm_fd;
#if LIBDRM_MAJOR_VERSION >= 2 && LIBDRM_MINOR_VERSION >= 4 && LIBDRM_MICRO_VERSION >= 47
- int has_universal_plane;
+ int has_universal_plane;
#endif
#if HAVE_UDEV
- struct udev_monitor *uevent_monitor;
- tdm_event_loop_source *uevent_source;
+ struct udev_monitor *uevent_monitor;
+ tdm_event_loop_source *uevent_source;
#endif
- drmModeResPtr mode_res;
- drmModePlaneResPtr plane_res;
+ drmModeResPtr mode_res;
+ drmModePlaneResPtr plane_res;
- struct list_head output_list;
- struct list_head buffer_list;
+ struct list_head output_list;
+ struct list_head buffer_list;
} tdm_drm_data;
-uint32_t tdm_drm_format_to_drm_format(tbm_format format);
+uint32_t tdm_drm_format_to_drm_format(tbm_format format);
tbm_format tdm_drm_format_to_tbm_format(uint32_t format);
-void tdm_drm_display_update_output_status(tdm_drm_data *drm_data);
-tdm_error tdm_drm_display_create_output_list(tdm_drm_data *drm_data);
-void tdm_drm_display_destroy_output_list(tdm_drm_data *drm_data);
-tdm_error tdm_drm_display_create_layer_list(tdm_drm_data *drm_data);
+void tdm_drm_display_update_output_status(tdm_drm_data *drm_data);
+tdm_error tdm_drm_display_create_output_list(tdm_drm_data *drm_data);
+void tdm_drm_display_destroy_output_list(tdm_drm_data *drm_data);
+tdm_error tdm_drm_display_create_layer_list(tdm_drm_data *drm_data);
#endif /* _TDM_DRM_H_ */
typedef struct _tdm_drm_event_data tdm_drm_event_data;
typedef enum {
- TDM_DRM_EVENT_TYPE_WAIT,
- TDM_DRM_EVENT_TYPE_COMMIT,
- TDM_DRM_EVENT_TYPE_PAGEFLIP,
+ TDM_DRM_EVENT_TYPE_WAIT,
+ TDM_DRM_EVENT_TYPE_COMMIT,
+ TDM_DRM_EVENT_TYPE_PAGEFLIP,
} tdm_drm_event_type;
typedef struct _tdm_drm_display_buffer {
for (i = 0; i < output_data->count_modes; i++) {
drmModeModeInfoPtr drm_mode = &output_data->drm_modes[i];
if ((drm_mode->hdisplay == output_data->current_mode->hdisplay) &&
- (drm_mode->vdisplay == output_data->current_mode->vdisplay) &&
- (drm_mode->vrefresh == output_data->current_mode->vrefresh) &&
- (drm_mode->flags == output_data->current_mode->flags) &&
- (drm_mode->type == output_data->current_mode->type) &&
- !(strncmp(drm_mode->name, output_data->current_mode->name, TDM_NAME_LEN)))
+ (drm_mode->vdisplay == output_data->current_mode->vdisplay) &&
+ (drm_mode->vrefresh == output_data->current_mode->vrefresh) &&
+ (drm_mode->flags == output_data->current_mode->flags) &&
+ (drm_mode->type == output_data->current_mode->type) &&
+ !(strncmp(drm_mode->name, output_data->current_mode->name, TDM_NAME_LEN)))
return drm_mode;
}
static void
_tdm_drm_display_to_tdm_mode(drmModeModeInfoPtr drm_mode,
- tdm_output_mode *tdm_mode)
+ tdm_output_mode *tdm_mode)
{
tdm_mode->clock = drm_mode->clock;
tdm_mode->hdisplay = drm_mode->hdisplay;
}
static tdm_error
-_tdm_drm_display_get_cur_msc (int fd, int pipe, uint *msc)
+_tdm_drm_display_get_cur_msc(int fd, int pipe, uint *msc)
{
drmVBlank vbl;
static tdm_error
_tdm_drm_output_update_status(tdm_drm_output_data *output_data,
- tdm_output_conn_status status)
+ tdm_output_conn_status status)
{
RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
if (output_data->status_func)
output_data->status_func(output_data, status,
- output_data->status_user_data);
+ output_data->status_user_data);
return TDM_ERROR_NONE;
}
static tdm_error
_tdm_drm_display_commit_primary_layer(tdm_drm_layer_data *layer_data,
- void *user_data, int *do_waitvblank)
+ void *user_data, int *do_waitvblank)
{
tdm_drm_data *drm_data = layer_data->drm_data;
tdm_drm_output_data *output_data = layer_data->output_data;
}
if (drmModeSetCrtc(drm_data->drm_fd, output_data->crtc_id,
- layer_data->display_buffer->fb_id, 0, 0,
- &output_data->connector_id, 1, mode)) {
+ layer_data->display_buffer->fb_id, 0, 0,
+ &output_data->connector_id, 1, mode)) {
TDM_ERR("set crtc failed: %m");
return TDM_ERROR_OPERATION_FAILED;
}
if (!layer_data->display_buffer) {
if (drmModeSetCrtc(drm_data->drm_fd, output_data->crtc_id,
- 0, 0, 0, NULL, 0, NULL)) {
+ 0, 0, 0, NULL, 0, NULL)) {
TDM_ERR("unset crtc failed: %m");
return TDM_ERROR_OPERATION_FAILED;
}
event_data->output_data = output_data;
event_data->user_data = user_data;
if (drmModePageFlip(drm_data->drm_fd, output_data->crtc_id,
- layer_data->display_buffer->fb_id, DRM_MODE_PAGE_FLIP_EVENT, event_data)) {
+ layer_data->display_buffer->fb_id, DRM_MODE_PAGE_FLIP_EVENT, event_data)) {
TDM_ERR("pageflip failed: %m");
free(event_data);
return TDM_ERROR_OPERATION_FAILED;
if (!layer_data->display_buffer) {
if (drmModeSetPlane(drm_data->drm_fd, layer_data->plane_id,
- output_data->crtc_id, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+ output_data->crtc_id, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
TDM_ERR("unset plane(%d) filed: %m", layer_data->plane_id);
return TDM_ERROR_NONE;
fh = ((unsigned int)layer_data->info.src_config.pos.h) << 16;
if (drmModeSetPlane(drm_data->drm_fd, layer_data->plane_id,
- output_data->crtc_id, layer_data->display_buffer->fb_id, 0,
- layer_data->info.dst_pos.x, layer_data->info.dst_pos.y,
- layer_data->info.dst_pos.w, layer_data->info.dst_pos.h,
- fx, fy, fw, fh) < 0) {
+ output_data->crtc_id, layer_data->display_buffer->fb_id, 0,
+ layer_data->info.dst_pos.x, layer_data->info.dst_pos.y,
+ layer_data->info.dst_pos.w, layer_data->info.dst_pos.h,
+ fx, fy, fw, fh) < 0) {
TDM_ERR("set plane(%d) failed: %m", layer_data->plane_id);
return TDM_ERROR_OPERATION_FAILED;
}
static void
_tdm_drm_display_cb_event(int fd, unsigned int sequence,
- unsigned int tv_sec, unsigned int tv_usec,
- void *user_data)
+ unsigned int tv_sec, unsigned int tv_usec,
+ void *user_data)
{
tdm_drm_event_data *event_data = user_data;
tdm_drm_output_data *output_data;
case TDM_DRM_EVENT_TYPE_PAGEFLIP:
if (output_data->commit_func)
output_data->commit_func(output_data, sequence, tv_sec, tv_usec,
- event_data->user_data);
+ event_data->user_data);
break;
case TDM_DRM_EVENT_TYPE_WAIT:
if (output_data->vblank_func)
output_data->vblank_func(output_data, sequence, tv_sec, tv_usec,
- event_data->user_data);
+ event_data->user_data);
break;
case TDM_DRM_EVENT_TYPE_COMMIT:
if (output_data->commit_func)
output_data->commit_func(output_data, sequence, tv_sec, tv_usec,
- event_data->user_data);
+ event_data->user_data);
break;
default:
break;
layer_data->plane_id = drm_data->plane_res->planes[i];
layer_data->capabilities = TDM_LAYER_CAPABILITY_PRIMARY |
- TDM_LAYER_CAPABILITY_GRAPHIC;
+ TDM_LAYER_CAPABILITY_GRAPHIC;
output_data->primary_layer = layer_data;
TDM_INFO("layer_data(%p) plane_id(%d) crtc_id(%d) capabilities(%x)",
- layer_data, layer_data->plane_id, layer_data->output_data->crtc_id,
- layer_data->capabilities);
+ layer_data, layer_data->plane_id, layer_data->output_data->crtc_id,
+ layer_data->capabilities);
LIST_ADDTAIL(&layer_data->link, &output_data->layer_list);
static tdm_error
_tdm_drm_display_get_property(tdm_drm_data *drm_data,
- unsigned int obj_id, unsigned int obj_type,
- const char *name, unsigned int *value,
- int *is_immutable)
+ unsigned int obj_id, unsigned int obj_type,
+ const char *name, unsigned int *value,
+ int *is_immutable)
{
drmModeObjectPropertiesPtr props = NULL;
int i;
for (i = 0; i < props->count_props; i++) {
drmModePropertyPtr prop = drmModeGetProperty(drm_data->drm_fd,
- props->props[i]);
+ props->props[i]);
if (!prop)
continue;
}
ret = _tdm_drm_display_get_property(drm_data,
- drm_data->plane_res->planes[0],
- DRM_MODE_OBJECT_PLANE, "type", &type,
- NULL);
+ drm_data->plane_res->planes[0],
+ DRM_MODE_OBJECT_PLANE, "type", &type,
+ NULL);
if (ret != TDM_ERROR_NONE) {
TDM_ERR("plane doesn't have 'type' property. Call a fallback function");
}
ret = _tdm_drm_display_get_property(drm_data,
- drm_data->plane_res->planes[i],
- DRM_MODE_OBJECT_PLANE, "type", &type,
- NULL);
+ drm_data->plane_res->planes[i],
+ DRM_MODE_OBJECT_PLANE, "type", &type,
+ NULL);
if (ret != TDM_ERROR_NONE) {
drmModeFreePlane(plane);
TDM_ERR("plane(%d) doesn't have 'type' info",
- drm_data->plane_res->planes[i]);
+ drm_data->plane_res->planes[i]);
goto failed;
}
if (types[i] == DRM_PLANE_TYPE_CURSOR) {
layer_data->capabilities = TDM_LAYER_CAPABILITY_CURSOR |
- TDM_LAYER_CAPABILITY_GRAPHIC;
+ TDM_LAYER_CAPABILITY_GRAPHIC;
layer_data->zpos = cpos_next++;
} else if (types[i] == DRM_PLANE_TYPE_OVERLAY) {
layer_data->capabilities = TDM_LAYER_CAPABILITY_OVERLAY |
- TDM_LAYER_CAPABILITY_GRAPHIC;
+ TDM_LAYER_CAPABILITY_GRAPHIC;
layer_data->zpos = opos_next++;
} else if (types[i] == DRM_PLANE_TYPE_PRIMARY) {
layer_data->capabilities = TDM_LAYER_CAPABILITY_PRIMARY |
- TDM_LAYER_CAPABILITY_GRAPHIC;
+ TDM_LAYER_CAPABILITY_GRAPHIC;
layer_data->zpos = 0;
output_data->primary_layer = layer_data;
} else {
}
TDM_INFO("layer_data(%p) plane_id(%d) crtc_id(%d) zpos(%d) capabilities(%x)",
- layer_data, layer_data->plane_id, layer_data->output_data->crtc_id,
- layer_data->zpos, layer_data->capabilities);
+ layer_data, layer_data->plane_id, layer_data->output_data->crtc_id,
+ layer_data->zpos, layer_data->capabilities);
LIST_ADDTAIL(&layer_data->link, &output_data->layer_list);
}
tdm_output_conn_status new_status;
connector = drmModeGetConnector(drm_data->drm_fd,
- output_data->connector_id);
+ output_data->connector_id);
if (!connector) {
TDM_ERR("no connector: %d", output_data->connector_id);
continue;
int crtc_id = 0, c, j;
RETURN_VAL_IF_FAIL(LIST_IS_EMPTY(&drm_data->output_list),
- TDM_ERROR_OPERATION_FAILED);
+ TDM_ERROR_OPERATION_FAILED);
/* check if there is a connected output */
for (i = 0; i < drm_data->mode_res->count_connectors; i++) {
connector = drmModeGetConnector(drm_data->drm_fd,
- drm_data->mode_res->connectors[i]);
+ drm_data->mode_res->connectors[i]);
if (!connector) {
TDM_ERR("no connector");
return TDM_ERROR_OPERATION_FAILED;
* should be implemented.
*/
connector = drmModeGetConnector(drm_data->drm_fd,
- drm_data->mode_res->connectors[conn_idx]);
+ drm_data->mode_res->connectors[conn_idx]);
if (!connector) {
TDM_ERR("no connector");
ret = TDM_ERROR_OPERATION_FAILED;
for (j = 0; j < connector->count_props; j++) {
drmModePropertyPtr prop = drmModeGetProperty(drm_data->drm_fd,
- connector->props[j]);
+ connector->props[j]);
if (!prop)
continue;
if (!strcmp(prop->name, "DPMS")) {
output_data->count_modes = connector->count_modes;
output_data->drm_modes = calloc(connector->count_modes,
- sizeof(drmModeModeInfo));
+ sizeof(drmModeModeInfo));
if (!output_data->drm_modes) {
TDM_ERR("alloc failed");
free(output_data);
goto failed_create;
}
output_data->output_modes = calloc(connector->count_modes,
- sizeof(tdm_output_mode));
+ sizeof(tdm_output_mode));
if (!output_data->output_modes) {
TDM_ERR("alloc failed");
free(output_data->drm_modes);
for (j = 0; j < connector->count_modes; j++) {
output_data->drm_modes[j] = connector->modes[j];
_tdm_drm_display_to_tdm_mode(&output_data->drm_modes[j],
- &output_data->output_modes[j]);
+ &output_data->output_modes[j]);
}
LIST_ADDTAIL(&output_data->link, &drm_data->output_list);
TDM_DBG("output_data(%p) connector_id(%d:%d:%d-%d) encoder_id(%d) crtc_id(%d) pipe(%d) dpms_id(%d)",
- output_data, output_data->connector_id, output_data->status,
- output_data->connector_type,
- output_data->connector_type_id, output_data->encoder_id, output_data->crtc_id,
- output_data->pipe, output_data->dpms_prop_id);
+ output_data, output_data->connector_id, output_data->status,
+ output_data->connector_type,
+ output_data->connector_type_id, output_data->encoder_id, output_data->crtc_id,
+ output_data->pipe, output_data->dpms_prop_id);
drmModeFreeEncoder(encoder);
drmModeFreeConnector(connector);
}
props = drmModeObjectGetProperties(drm_data->drm_fd, output_data->crtc_id,
- DRM_MODE_OBJECT_CRTC);
+ DRM_MODE_OBJECT_CRTC);
if (!props) {
ret = TDM_ERROR_OPERATION_FAILED;
TDM_ERR("get crtc properties failed: %m\n");
drm_data = output_data->drm_data;
ret = drmModeObjectSetProperty(drm_data->drm_fd,
- output_data->crtc_id, DRM_MODE_OBJECT_CRTC,
- id, value.u32);
+ output_data->crtc_id, DRM_MODE_OBJECT_CRTC,
+ id, value.u32);
if (ret < 0) {
TDM_ERR("set property failed: %m");
return TDM_ERROR_OPERATION_FAILED;
drm_data = output_data->drm_data;
props = drmModeObjectGetProperties(drm_data->drm_fd, output_data->crtc_id,
- DRM_MODE_OBJECT_CRTC);
+ DRM_MODE_OBJECT_CRTC);
if (props == NULL) {
TDM_ERR("get property failed: %m");
return TDM_ERROR_OPERATION_FAILED;
tdm_error
drm_output_wait_vblank(tdm_output *output, int interval, int sync,
- void *user_data)
+ void *user_data)
{
tdm_drm_output_data *output_data = output;
tdm_drm_data *drm_data;
drm_data = output_data->drm_data;
ret = _tdm_drm_display_get_cur_msc(drm_data->drm_fd, output_data->pipe,
- &target_msc);
+ &target_msc);
if (ret != TDM_ERROR_NONE)
goto failed_vblank;
event_data->user_data = user_data;
ret = _tdm_drm_display_wait_vblank(drm_data->drm_fd, output_data->pipe,
- &target_msc, event_data);
+ &target_msc, event_data);
if (ret != TDM_ERROR_NONE)
goto failed_vblank;
tdm_error
drm_output_set_vblank_handler(tdm_output *output,
- tdm_output_vblank_handler func)
+ tdm_output_vblank_handler func)
{
tdm_drm_output_data *output_data = output;
LIST_FOR_EACH_ENTRY(layer_data, &output_data->layer_list, link) {
if (layer_data == output_data->primary_layer) {
ret = _tdm_drm_display_commit_primary_layer(layer_data, user_data,
- &do_waitvblank);
+ &do_waitvblank);
if (ret != TDM_ERROR_NONE)
return ret;
} else {
}
ret = _tdm_drm_display_get_cur_msc(drm_data->drm_fd, output_data->pipe,
- &target_msc);
+ &target_msc);
if (ret != TDM_ERROR_NONE) {
free(event_data);
return ret;
event_data->user_data = user_data;
ret = _tdm_drm_display_wait_vblank(drm_data->drm_fd, output_data->pipe,
- &target_msc, event_data);
+ &target_msc, event_data);
if (ret != TDM_ERROR_NONE) {
free(event_data);
return ret;
tdm_error
drm_output_set_commit_handler(tdm_output *output,
- tdm_output_commit_handler func)
+ tdm_output_commit_handler func)
{
tdm_drm_output_data *output_data = output;
drm_data = output_data->drm_data;
ret = drmModeObjectSetProperty(drm_data->drm_fd,
- output_data->connector_id, DRM_MODE_OBJECT_CONNECTOR,
- output_data->dpms_prop_id, dpms_value);
+ output_data->connector_id, DRM_MODE_OBJECT_CONNECTOR,
+ output_data->dpms_prop_id, dpms_value);
if (ret < 0) {
TDM_ERR("set dpms failed: %m");
return TDM_ERROR_OPERATION_FAILED;
drm_data = output_data->drm_data;
props = drmModeObjectGetProperties(drm_data->drm_fd, output_data->connector_id,
- DRM_MODE_OBJECT_CONNECTOR);
+ DRM_MODE_OBJECT_CONNECTOR);
if (props == NULL) {
TDM_ERR("get property failed: %m");
return TDM_ERROR_OPERATION_FAILED;
tdm_error
drm_output_set_status_handler(tdm_output *output,
- tdm_output_status_handler func,
- void *user_data)
+ tdm_output_status_handler func,
+ void *user_data)
{
tdm_drm_output_data *output_data = output;
for (i = 0; i < caps->format_count; i++) {
/* TODO: kernel reports wrong formats */
if (plane->formats[i] != DRM_FORMAT_XRGB8888 &&
- plane->formats[i] != DRM_FORMAT_ARGB8888) {
+ plane->formats[i] != DRM_FORMAT_ARGB8888) {
TDM_WRN("plane(%d) zpos(%d) %c%c%c%c skipped",
layer_data->plane_id, layer_data->zpos, FOURCC_STR(plane->formats[i]));
continue;
caps->format_count = format_count;
props = drmModeObjectGetProperties(drm_data->drm_fd, layer_data->plane_id,
- DRM_MODE_OBJECT_PLANE);
+ DRM_MODE_OBJECT_PLANE);
if (!props) {
ret = TDM_ERROR_OPERATION_FAILED;
TDM_ERR("get plane properties failed: %m\n");
drm_data = layer_data->drm_data;
ret = drmModeObjectSetProperty(drm_data->drm_fd,
- layer_data->plane_id, DRM_MODE_OBJECT_PLANE,
- id, value.u32);
+ layer_data->plane_id, DRM_MODE_OBJECT_PLANE,
+ id, value.u32);
if (ret < 0) {
TDM_ERR("set property failed: %m");
return TDM_ERROR_OPERATION_FAILED;
drm_data = layer_data->drm_data;
props = drmModeObjectGetProperties(drm_data->drm_fd, layer_data->plane_id,
- DRM_MODE_OBJECT_PLANE);
+ DRM_MODE_OBJECT_PLANE);
if (props == NULL) {
TDM_ERR("get property failed: %m");
return TDM_ERROR_OPERATION_FAILED;
display_buffer->buffer = buffer;
err = tdm_buffer_add_destroy_handler(buffer, _tdm_drm_display_cb_destroy_buffer,
- drm_data);
+ drm_data);
if (err != TDM_ERROR_NONE) {
TDM_ERR("add destroy handler fail");
free(display_buffer);
tbm_surface_internal_get_plane_data(buffer, i, &size, &offsets[i], &pitches[i]);
ret = drmModeAddFB2(drm_data->drm_fd, width, height, format,
- handles, pitches, offsets, &display_buffer->fb_id, 0);
+ handles, pitches, offsets, &display_buffer->fb_id, 0);
if (ret < 0) {
TDM_ERR("add fb failed: %m");
return TDM_ERROR_OPERATION_FAILED;
}
TDM_DBG("drm_data->drm_fd : %d, display_buffer->fb_id:%u", drm_data->drm_fd,
- display_buffer->fb_id);
+ display_buffer->fb_id);
if (IS_RGB(format))
display_buffer->width = pitches[0] >> 2;
int
_tdm_drm_pp_pixman_convert(pixman_op_t op,
- unsigned char *srcbuf, unsigned char *dstbuf,
- pixman_format_code_t src_format, pixman_format_code_t dst_format,
- int sbw, int sbh, int sx, int sy, int sw, int sh,
- int dbw, int dbh, int dx, int dy, int dw, int dh,
- int rotate, int hflip, int vflip)
+ unsigned char *srcbuf, unsigned char *dstbuf,
+ pixman_format_code_t src_format, pixman_format_code_t dst_format,
+ int sbw, int sbh, int sx, int sy, int sw, int sh,
+ int dbw, int dbh, int dx, int dy, int dw, int dh,
+ int rotate, int hflip, int vflip)
{
- pixman_image_t *src_img;
- pixman_image_t *dst_img;
+ pixman_image_t *src_img;
+ pixman_image_t *dst_img;
struct pixman_f_transform ft;
pixman_transform_t transform;
- int src_stride, dst_stride;
- int src_bpp;
- int dst_bpp;
- double scale_x, scale_y;
- int rotate_step;
- int ret = 0;
+ int src_stride, dst_stride;
+ int src_bpp;
+ int dst_bpp;
+ double scale_x, scale_y;
+ int rotate_step;
+ int ret = 0;
RETURN_VAL_IF_FAIL(srcbuf != NULL, 0);
RETURN_VAL_IF_FAIL(dstbuf != NULL, 0);
TDM_DBG("src(%dx%d: %d,%d %dx%d) dst(%dx%d: %d,%d %dx%d) flip(%d,%d), rot(%d)",
- sbw, sbh, sx, sy, sw, sh, dbw, dbh, dx, dy, dw, dh, hflip, vflip, rotate);
+ sbw, sbh, sx, sy, sw, sh, dbw, dbh, dx, dy, dw, dh, hflip, vflip, rotate);
src_bpp = PIXMAN_FORMAT_BPP(src_format) / 8;
RETURN_VAL_IF_FAIL(src_bpp > 0, 0);
dst_stride = dbw * dst_bpp;
src_img = pixman_image_create_bits(src_format, sbw, sbh, (uint32_t *)srcbuf,
- src_stride);
+ src_stride);
dst_img = pixman_image_create_bits(dst_format, dbw, dbh, (uint32_t *)dstbuf,
- dst_stride);
+ dst_stride);
GOTO_IF_FAIL(src_img != NULL, CANT_CONVERT);
GOTO_IF_FAIL(dst_img != NULL, CANT_CONVERT);
dst_format = PIXMAN_a8b8g8r8;
else if (dst_info.format == TBM_FORMAT_YVU420) {
TDM_ERR("can't convert %c%c%c%c to %c%c%c%c",
- FOURCC_STR(src_info.format), FOURCC_STR(dst_info.format));
+ FOURCC_STR(src_info.format), FOURCC_STR(dst_info.format));
goto fail_convert;
}
}
}
_tdm_drm_pp_pixman_convert(PIXMAN_OP_SRC,
- src_info.planes[0].ptr, dst_info.planes[0].ptr,
- src_format, dst_format,
- sbw, src_info.height,
- info->src_config.pos.x, info->src_config.pos.y,
- info->src_config.pos.w, info->src_config.pos.h,
- dbw, dst_info.height,
- info->dst_config.pos.x, info->dst_config.pos.y,
- info->dst_config.pos.w, info->dst_config.pos.h,
- rotate, hflip, 0);
+ src_info.planes[0].ptr, dst_info.planes[0].ptr,
+ src_format, dst_format,
+ sbw, src_info.height,
+ info->src_config.pos.x, info->src_config.pos.y,
+ info->src_config.pos.w, info->src_config.pos.h,
+ dbw, dst_info.height,
+ info->dst_config.pos.x, info->dst_config.pos.y,
+ info->dst_config.pos.w, info->dst_config.pos.h,
+ rotate, hflip, 0);
tbm_surface_unmap(buffer->src);
tbm_surface_unmap(buffer->dst);
RETURN_VAL_IF_FAIL(dst, TDM_ERROR_INVALID_PARAMETER);
if (tbm_surface_internal_get_num_bos(src) > 1 ||
- tbm_surface_internal_get_num_bos(dst) > 1) {
+ tbm_surface_internal_get_num_bos(dst) > 1) {
TDM_ERR("can't handle multiple tbm bos");
return TDM_ERROR_OPERATION_FAILED;
}
if (pp_data->done_func)
pp_data->done_func(pp_data,
- b->src,
- b->dst,
- pp_data->done_user_data);
+ b->src,
+ b->dst,
+ pp_data->done_user_data);
free(b);
}
projects / platform / adaptation / libtdm-drm.git / commitdiff