src/tdm_drm.c

   1 #ifdef HAVE_CONFIG_H
   2 #include "config.h"
   3 #endif
   4
   5 #if HAVE_UDEV
   6 #include <libudev.h>
   7 #endif
   8
   9 #include "tdm_drm.h"
  10 #include <tdm_helper.h>
  11 #include <tbm_drm_helper.h>
  12
  13 #define ENABLE_PP
  14
  15 #define TDM_DRM_NAME "vigs"
  16
  17 #define TDM_HWC 1
  18
  19 static tdm_drm_data *drm_data;
  20
  21 #ifdef HAVE_UDEV
  22 static struct udev_device *
  23 _tdm_find_primary_gpu(void)
  24 {
  25         struct udev *udev;
  26         struct udev_enumerate *e;
  27         struct udev_list_entry *entry;
  28         const char *path, *id;
  29         struct udev_device *device, *drm_device, *pci;
  30
  31         udev = udev_new();
  32         if (!udev) {
  33                 TDM_ERR("fail to initialize udev context\n");
  34                 return NULL;
  35         }
  36
  37         e = udev_enumerate_new(udev);
  38         udev_enumerate_add_match_subsystem(e, "drm");
  39         udev_enumerate_add_match_sysname(e, "card[0-9]*");
  40
  41         udev_enumerate_scan_devices(e);
  42         drm_device = NULL;
  43         udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
  44                 path = udev_list_entry_get_name(entry);
  45                 device = udev_device_new_from_syspath(udev, path);
  46                 if (!device)
  47                         continue;
  48
  49                 pci = udev_device_get_parent_with_subsystem_devtype(device,
  50                                                 "pci", NULL);
  51                 if (pci) {
  52                         id = udev_device_get_sysattr_value(pci, "boot_vga");
  53                         if (id && !strcmp(id, "1")) {
  54                                 if (drm_device)
  55                                         udev_device_unref(drm_device);
  56                                 drm_device = device;
  57                                 break;
  58                         }
  59                 }
  60
  61                 if (!drm_device)
  62                         drm_device = device;
  63                 else
  64                         udev_device_unref(device);
  65         }
  66
  67         udev_enumerate_unref(e);
  68         return drm_device;
  69 }
  70
  71 static tdm_error
  72 _tdm_drm_udev_fd_handler(int fd, tdm_event_loop_mask mask, void *user_data)
  73 {
  74         tdm_drm_data *edata = (tdm_drm_data*)user_data;
  75         struct udev_device *dev;
  76         const char *hotplug;
  77         struct stat s;
  78         dev_t udev_devnum;
  79         int ret;
  80
  81         dev = udev_monitor_receive_device(edata->uevent_monitor);
  82         if (!dev) {
  83                 TDM_ERR("couldn't receive device");
  84                 return TDM_ERROR_OPERATION_FAILED;
  85         }
  86
  87         udev_devnum = udev_device_get_devnum(dev);
  88
  89         ret = fstat(edata->drm_fd, &s);
  90         if (ret == -1) {
  91                 TDM_ERR("fstat failed");
  92                 return TDM_ERROR_OPERATION_FAILED;
  93         }
  94
  95         hotplug = udev_device_get_property_value(dev, "HOTPLUG");
  96
  97         if (memcmp(&s.st_rdev, &udev_devnum, sizeof(dev_t)) == 0 &&
  98                         hotplug && atoi(hotplug) == 1) {
  99                 TDM_INFO("HotPlug");
 100                 tdm_drm_display_update_output_status(edata);
 101         }
 102
 103         udev_device_unref(dev);
 104
 105         return TDM_ERROR_NONE;
 106 }
 107
 108 static void
 109 _tdm_drm_udev_init(tdm_drm_data *edata)
 110 {
 111         struct udev *u = NULL;
 112         struct udev_monitor *mon = NULL;
 113
 114         u = udev_new();
 115         if (!u) {
 116                 TDM_ERR("couldn't create udev");
 117                 goto failed;
 118         }
 119
 120         mon = udev_monitor_new_from_netlink(u, "udev");
 121         if (!mon) {
 122                 TDM_ERR("couldn't create udev monitor");
 123                 goto failed;
 124         }
 125
 126         if (udev_monitor_filter_add_match_subsystem_devtype(mon, "drm", "drm_minor") > 0 ||
 127                 udev_monitor_enable_receiving(mon) < 0) {
 128                 TDM_ERR("add match subsystem failed");
 129                 goto failed;
 130         }
 131
 132         edata->uevent_source =
 133                 tdm_event_loop_add_fd_handler(edata->dpy, udev_monitor_get_fd(mon),
 134                                                                           TDM_EVENT_LOOP_READABLE,
 135                                                                           _tdm_drm_udev_fd_handler,
 136                                                                           edata, NULL);
 137         if (!edata->uevent_source) {
 138                 TDM_ERR("couldn't create udev event source");
 139                 goto failed;
 140         }
 141
 142         edata->uevent_monitor = mon;
 143
 144         TDM_INFO("hotplug monitor created");
 145
 146         return;
 147 failed:
 148         if (mon)
 149                 udev_monitor_unref(mon);
 150         if (u)
 151                 udev_unref(u);
 152 }
 153
 154 static void
 155 _tdm_drm_udev_deinit(tdm_drm_data *edata)
 156 {
 157         if (edata->uevent_source) {
 158                 tdm_event_loop_source_remove(edata->uevent_source);
 159                 edata->uevent_source = NULL;
 160         }
 161
 162         if (edata->uevent_monitor) {
 163                 struct udev *u = udev_monitor_get_udev(edata->uevent_monitor);
 164                 udev_monitor_unref(edata->uevent_monitor);
 165                 udev_unref(u);
 166                 edata->uevent_monitor = NULL;
 167                 TDM_INFO("hotplug monitor destroyed");
 168         }
 169 }
 170 #endif
 171
 172 static int
 173 _tdm_drm_open_drm(void)
 174 {
 175         int fd = -1;
 176
 177         fd = drmOpen(TDM_DRM_NAME, NULL);
 178         if (fd < 0)
 179                 TDM_WRN("Cannot open '%s' drm", TDM_DRM_NAME);
 180
 181 #ifdef HAVE_UDEV
 182         if (fd < 0) {
 183                 struct udev_device *drm_device = NULL;
 184                 const char *filename;
 185                 TDM_WRN("Cannot open drm device.. search by udev");
 186
 187                 drm_device = _tdm_find_primary_gpu();
 188                 if (drm_device == NULL) {
 189                         TDM_ERR("fail to find drm device\n");
 190                         goto close_l;
 191                 }
 192
 193                 filename = udev_device_get_devnode(drm_device);
 194
 195                 fd = open(filename, O_RDWR | O_CLOEXEC);
 196                 if (fd < 0)
 197                         TDM_ERR("Cannot open drm device(%s)\n", filename);
 198
 199                 TDM_DBG("open drm device (name:%s, fd:%d)", filename, fd);
 200
 201                 udev_device_unref(drm_device);
 202         }
 203 close_l:
 204 #endif
 205         return fd;
 206 }
 207
 208 void
 209 tdm_drm_deinit(tdm_backend_data *bdata)
 210 {
 211         if (drm_data != bdata)
 212                 return;
 213
 214         TDM_INFO("deinit");
 215
 216 #ifdef HAVE_UDEV
 217         _tdm_drm_udev_deinit(drm_data);
 218 #endif
 219
 220         tdm_drm_display_destroy_output_list(drm_data);
 221
 222         if (drm_data->plane_res)
 223                 drmModeFreePlaneResources(drm_data->plane_res);
 224         if (drm_data->mode_res)
 225                 drmModeFreeResources(drm_data->mode_res);
 226         if (drm_data->drm_fd >= 0)
 227                 close(drm_data->drm_fd);
 228
 229         free(drm_data);
 230         drm_data = NULL;
 231 }
 232
 233 tdm_backend_data *
 234 tdm_drm_init(tdm_display *dpy, tdm_error *error)
 235 {
 236         tdm_func_display drm_func_display;
 237         tdm_func_output drm_func_output;
 238         tdm_func_layer drm_func_layer;
 239         tdm_func_hwc drm_func_hwc;
 240         tdm_func_hwc_window drm_func_hwc_window;
 241 #ifdef ENABLE_PP
 242         tdm_func_pp drm_func_pp;
 243 #endif
 244         tdm_error ret;
 245
 246         if (!dpy) {
 247                 TDM_ERR("display is null");
 248                 if (error)
 249                         *error = TDM_ERROR_INVALID_PARAMETER;
 250                 return NULL;
 251         }
 252
 253         if (drm_data) {
 254                 TDM_ERR("failed: init twice");
 255                 if (error)
 256                         *error = TDM_ERROR_BAD_REQUEST;
 257                 return NULL;
 258         }
 259
 260         drm_data = calloc(1, sizeof(tdm_drm_data));
 261         if (!drm_data) {
 262                 TDM_ERR("alloc failed");
 263                 if (error)
 264                         *error = TDM_ERROR_OUT_OF_MEMORY;
 265                 return NULL;
 266         }
 267
 268 #if TDM_HWC
 269         /* enable the tdm_hwc */
 270         drm_data->hwc_mode = 1;
 271 #endif
 272
 273         LIST_INITHEAD(&drm_data->output_list);
 274         LIST_INITHEAD(&drm_data->buffer_list);
 275
 276         memset(&drm_func_display, 0, sizeof(drm_func_display));
 277         drm_func_display.display_get_capability = drm_display_get_capability;
 278         drm_func_display.display_get_pp_capability = drm_display_get_pp_capability;
 279         drm_func_display.display_get_outputs = drm_display_get_outputs;
 280         drm_func_display.display_get_fd = drm_display_get_fd;
 281         drm_func_display.display_handle_events = drm_display_handle_events;
 282         drm_func_display.display_create_pp = drm_display_create_pp;
 283
 284         memset(&drm_func_output, 0, sizeof(drm_func_output));
 285         drm_func_output.output_get_capability = drm_output_get_capability;
 286         drm_func_output.output_get_layers = drm_output_get_layers;
 287         drm_func_output.output_set_property = drm_output_set_property;
 288         drm_func_output.output_get_property = drm_output_get_property;
 289         drm_func_output.output_wait_vblank = drm_output_wait_vblank;
 290         drm_func_output.output_set_vblank_handler = drm_output_set_vblank_handler;
 291         drm_func_output.output_commit = drm_output_commit;
 292         drm_func_output.output_set_commit_handler = drm_output_set_commit_handler;
 293         drm_func_output.output_set_dpms = drm_output_set_dpms;
 294         drm_func_output.output_get_dpms = drm_output_get_dpms;
 295         drm_func_output.output_set_mode = drm_output_set_mode;
 296         drm_func_output.output_get_mode = drm_output_get_mode;
 297 #ifdef HAVE_UDEV
 298         drm_func_output.output_set_status_handler = drm_output_set_status_handler;
 299 #endif
 300
 301         if (drm_data->hwc_mode) {
 302                 drm_func_output.output_get_hwc = drm_output_get_hwc;
 303
 304                 memset(&drm_func_hwc, 0, sizeof(drm_func_hwc));
 305                 drm_func_hwc.hwc_create_window = drm_hwc_create_window;
 306                 drm_func_hwc.hwc_get_video_supported_formats = drm_hwc_get_video_supported_formats;
 307                 drm_func_hwc.hwc_get_video_available_properties = NULL;
 308                 drm_func_hwc.hwc_get_capabilities = drm_hwc_get_capabilities;
 309                 drm_func_hwc.hwc_get_available_properties = drm_hwc_get_available_properties;
 310                 drm_func_hwc.hwc_get_client_target_buffer_queue = drm_hwc_get_client_target_buffer_queue;
 311                 drm_func_hwc.hwc_set_client_target_buffer = drm_hwc_set_client_target_buffer;
 312                 drm_func_hwc.hwc_validate = drm_hwc_validate;
 313                 drm_func_hwc.hwc_get_changed_composition_types = drm_hwc_get_changed_composition_types;
 314                 drm_func_hwc.hwc_accept_validation = drm_hwc_accept_validation;
 315                 drm_func_hwc.hwc_commit = drm_hwc_commit;
 316                 drm_func_hwc.hwc_set_commit_handler = drm_hwc_set_commit_handler;
 317
 318                 memset(&drm_func_hwc_window, 0, sizeof(drm_func_hwc_window));
 319                 drm_func_hwc_window.hwc_window_destroy = drm_hwc_window_destroy;
 320                 drm_func_hwc_window.hwc_window_acquire_buffer_queue = NULL; // no need
 321                 drm_func_hwc_window.hwc_window_release_buffer_queue = NULL; // no need
 322                 drm_func_hwc_window.hwc_window_set_composition_type = drm_hwc_window_set_composition_type;
 323                 drm_func_hwc_window.hwc_window_set_buffer_damage = drm_hwc_window_set_buffer_damage;
 324                 drm_func_hwc_window.hwc_window_set_info = drm_hwc_window_set_info;
 325                 drm_func_hwc_window.hwc_window_set_buffer = drm_hwc_window_set_buffer;
 326                 drm_func_hwc_window.hwc_window_set_property = drm_hwc_window_set_property;
 327                 drm_func_hwc_window.hwc_window_get_property = drm_hwc_window_get_property;
 328                 drm_func_hwc_window.hwc_window_get_constraints = drm_hwc_window_get_constraints;
 329                 drm_func_hwc_window.hwc_window_set_name = drm_hwc_window_set_name;
 330                 drm_func_hwc_window.hwc_window_set_cursor_image = drm_hwc_window_set_cursor_image;
 331         }
 332
 333         memset(&drm_func_layer, 0, sizeof(drm_func_layer));
 334         drm_func_layer.layer_get_capability = drm_layer_get_capability;
 335         drm_func_layer.layer_set_property = drm_layer_set_property;
 336         drm_func_layer.layer_get_property = drm_layer_get_property;
 337         drm_func_layer.layer_set_info = drm_layer_set_info;
 338         drm_func_layer.layer_get_info = drm_layer_get_info;
 339         drm_func_layer.layer_set_buffer = drm_layer_set_buffer;
 340         drm_func_layer.layer_unset_buffer = drm_layer_unset_buffer;
 341
 342 #ifdef ENABLE_PP
 343         memset(&drm_func_pp, 0, sizeof(drm_func_pp));
 344         drm_func_pp.pp_destroy = drm_pp_destroy;
 345         drm_func_pp.pp_set_info = drm_pp_set_info;
 346         drm_func_pp.pp_attach = drm_pp_attach;
 347         drm_func_pp.pp_commit = drm_pp_commit;
 348         drm_func_pp.pp_set_done_handler = drm_pp_set_done_handler;
 349 #endif
 350
 351         ret = tdm_backend_register_func_display(dpy, &drm_func_display);
 352         if (ret != TDM_ERROR_NONE)
 353                 goto failed;
 354
 355         ret = tdm_backend_register_func_output(dpy, &drm_func_output);
 356         if (ret != TDM_ERROR_NONE)
 357                 goto failed;
 358
 359         ret = tdm_backend_register_func_layer(dpy, &drm_func_layer);
 360         if (ret != TDM_ERROR_NONE)
 361                 goto failed;
 362
 363         if (drm_data->hwc_mode) {
 364                 ret = tdm_backend_register_func_hwc(dpy, &drm_func_hwc);
 365                 if (ret != TDM_ERROR_NONE)
 366                         goto failed;
 367
 368                 ret = tdm_backend_register_func_hwc_window(dpy, &drm_func_hwc_window);
 369                 if (ret != TDM_ERROR_NONE)
 370                         goto failed;
 371         }
 372
 373 #ifdef ENABLE_PP
 374         ret = tdm_backend_register_func_pp(dpy, &drm_func_pp);
 375         if (ret != TDM_ERROR_NONE)
 376                 goto failed;
 377 #endif
 378
 379         drm_data->dpy = dpy;
 380
 381         /* The drm master fd can be opened by a tbm backend module in
 382          * tbm_bufmgr_init() time. In this case, we just get it from tbm.
 383          */
 384         drm_data->drm_fd = tbm_drm_helper_get_master_fd();
 385         if (drm_data->drm_fd < 0) {
 386                 drm_data->drm_fd = _tdm_drm_open_drm();
 387
 388                 if (drm_data->drm_fd < 0) {
 389                         ret = TDM_ERROR_OPERATION_FAILED;
 390                         goto failed;
 391                 }
 392
 393                 tbm_drm_helper_set_tbm_master_fd(drm_data->drm_fd);
 394         }
 395
 396         TDM_INFO("master fd: %d", drm_data->drm_fd);
 397
 398 #ifdef HAVE_UDEV
 399         _tdm_drm_udev_init(drm_data);
 400 #endif
 401
 402 #if LIBDRM_MAJOR_VERSION >= 2 && LIBDRM_MINOR_VERSION >= 4  && LIBDRM_MICRO_VERSION >= 47
 403         if (drmSetClientCap(drm_data->drm_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1) < 0) {
 404                 TDM_WRN("Set DRM_CLIENT_CAP_UNIVERSAL_PLANES failed");
 405         } else {
 406                 TDM_INFO("has universal planes");
 407                 drm_data->has_universal_plane = 1;
 408         }
 409 #endif
 410
 411         drm_data->mode_res = drmModeGetResources(drm_data->drm_fd);
 412         if (!drm_data->mode_res) {
 413                 TDM_ERR("no drm resource: %m");
 414                 ret = TDM_ERROR_OPERATION_FAILED;
 415                 goto failed;
 416         }
 417
 418         drm_data->plane_res = drmModeGetPlaneResources(drm_data->drm_fd);
 419         if (!drm_data->plane_res) {
 420                 TDM_ERR("no drm plane resource: %m");
 421                 ret = TDM_ERROR_OPERATION_FAILED;
 422                 goto failed;
 423         }
 424
 425         if (drm_data->plane_res->count_planes <= 0) {
 426                 TDM_ERR("no drm plane resource");
 427                 ret = TDM_ERROR_OPERATION_FAILED;
 428                 goto failed;
 429         }
 430
 431         ret = tdm_drm_display_create_output_list(drm_data);
 432         if (ret != TDM_ERROR_NONE)
 433                 goto failed;
 434
 435         ret = tdm_drm_display_create_layer_list(drm_data);
 436         if (ret != TDM_ERROR_NONE)
 437                 goto failed;
 438
 439         if (error)
 440                 *error = TDM_ERROR_NONE;
 441
 442         TDM_INFO("init success!");
 443
 444         return (tdm_backend_data *)drm_data;
 445 failed:
 446         if (error)
 447                 *error = ret;
 448
 449         tdm_drm_deinit(drm_data);
 450
 451         TDM_ERR("init failed!");
 452         return NULL;
 453 }
 454
 455 tdm_backend_module tdm_backend_module_data = {
 456         "drm",
 457         "Samsung",
 458         TDM_BACKEND_SET_ABI_VERSION(1, 1),
 459         tdm_drm_init,
 460         tdm_drm_deinit
 461 };