static struct gbm_dev *
stereo_prepare_dev(int fd, const struct gbm_options *options)
{
drmModeRes *res;
drmModeConnector *conn;
struct gbm_dev *dev;
int ret;
/* retrieve resources */
res = drmModeGetResources(fd);
if (!res) {
fprintf(stderr, "cannot retrieve DRM resources (%d): %m\n",
errno);
goto error;
}
conn = get_connector(fd, res, options);
if (!conn)
goto error_resources;
/* create a device structure */
dev = xmalloc(sizeof(*dev));
memset(dev, 0, sizeof(*dev));
dev->conn = conn->connector_id;
dev->fd = fd;
/* call helper function to prepare this connector */
ret = stereo_setup_dev(res, conn, options, dev);
if (ret) {
if (ret != -ENOENT) {
errno = -ret;
fprintf(stderr,
"cannot setup device for connector "
"%u:%u (%d): %m\n",
0, res->connectors[0], errno);
}
goto error_dev;
}
drmModeFreeConnector(conn);
drmModeFreeResources(res);
return dev;
error_dev:
free(dev);
drmModeFreeConnector(conn);
error_resources:
drmModeFreeResources(res);
error:
return NULL;
}
static void free_drm_resources(gfx_ctx_drm_egl_data_t *drm)
{
if (!drm)
return;
if (drm->g_gbm_surface)
gbm_surface_destroy(drm->g_gbm_surface);
if (drm->g_gbm_dev)
gbm_device_destroy(drm->g_gbm_dev);
if (drm->g_encoder)
drmModeFreeEncoder(drm->g_encoder);
if (drm->g_connector)
drmModeFreeConnector(drm->g_connector);
if (drm->g_resources)
drmModeFreeResources(drm->g_resources);
if (drm->g_orig_crtc)
drmModeFreeCrtc(drm->g_orig_crtc);
if (drm->g_drm_fd >= 0)
close(drm->g_drm_fd);
drm->g_gbm_surface = NULL;
drm->g_gbm_dev = NULL;
drm->g_encoder = NULL;
drm->g_connector = NULL;
drm->g_resources = NULL;
drm->g_orig_crtc = NULL;
drm->g_drm_fd = -1;
}
static void free_drm_resources(void)
{
if (g_gbm_surface)
gbm_surface_destroy(g_gbm_surface);
if (g_gbm_dev)
gbm_device_destroy(g_gbm_dev);
if (g_encoder)
drmModeFreeEncoder(g_encoder);
if (g_connector)
drmModeFreeConnector(g_connector);
if (g_resources)
drmModeFreeResources(g_resources);
if (g_orig_crtc)
drmModeFreeCrtc(g_orig_crtc);
if (g_drm_fd >= 0)
close(g_drm_fd);
g_gbm_surface = NULL;
g_gbm_dev = NULL;
g_encoder = NULL;
g_connector = NULL;
g_resources = NULL;
g_orig_crtc = NULL;
g_drm_fd = -1;
}
bool CDRMUtils::OpenDrm()
{
std::vector<const char*>modules =
{
"i915",
"amdgpu",
"radeon",
"nouveau",
"vmwgfx",
"msm",
"imx-drm",
"rockchip",
"vc4",
"virtio_gpu",
"sun4i-drm",
};
for(int i = 0; i < 10; ++i)
{
std::string device = "/dev/dri/card";
device.append(std::to_string(i));
for (auto module : modules)
{
m_fd = drmOpen(module, device.c_str());
if (m_fd >= 0)
{
if(!GetResources())
{
continue;
}
if(!GetConnector())
{
continue;
}
drmModeFreeResources(m_drm_resources);
m_drm_resources = nullptr;
drmModeFreeConnector(m_connector->connector);
m_connector->connector = nullptr;
drmModeFreeObjectProperties(m_connector->props);
m_connector->props = nullptr;
drmModeFreeProperty(*m_connector->props_info);
*m_connector->props_info = nullptr;
CLog::Log(LOGDEBUG, "CDRMUtils::%s - opened device: %s using module: %s", __FUNCTION__, device.c_str(), module);
return true;
}
drmClose(m_fd);
m_fd = -1;
}
}
return false;
}
static drmModeConnector* getConnector(int fd, uint32_t connector_type)
{
LOGV("Entering %s, %d", __func__, connector_type);
drmModeRes *resources = drmModeGetResources(fd);
drmModeConnector *connector = NULL;
int i;
if (resources == NULL || resources->connectors == NULL) {
LOGE("%s: drmModeGetResources failed.", __func__);
return NULL;
}
for (i = 0; i < resources->count_connectors; i++) {
connector = drmModeGetConnector(fd, resources->connectors[i]);
if (connector == NULL)
continue;
if (connector->connector_type == connector_type)
break;
drmModeFreeConnector(connector);
connector = NULL;
}
drmModeFreeResources(resources);
if (connector == NULL) {
LOGE("%s: Failed to get conector", __func__);
}
LOGV("Leaving %s, %d", __func__, connector_type);
return connector;
}
void gralloc_drm_fini_kms(struct gralloc_drm_t *drm)
{
switch (drm->swap_mode) {
case DRM_SWAP_FLIP:
drm_kms_page_flip(drm, NULL);
break;
case DRM_SWAP_COPY:
{
struct gralloc_drm_bo_t **bo = (drm->current_front) ?
&drm->current_front : &drm->next_front;
if (*bo)
gralloc_drm_bo_destroy(*bo);
*bo = NULL;
}
break;
default:
break;
}
/* restore crtc? */
if (drm->resources) {
drmModeFreeResources(drm->resources);
drm->resources = NULL;
}
drm_singleton = NULL;
}
static int run_test(const char *test_name, enum test_flags flags)
{
int i;
resources = drmModeGetResources(drm_fd);
igt_assert(resources);
/* Find any connected displays */
for (i = 0; i < resources->count_connectors; i++) {
uint32_t connector_id;
int j;
connector_id = resources->connectors[i];
for (j = 0; j < resources->count_crtcs; j++) {
struct kmstest_connector_config cconf;
if (!kmstest_get_connector_config(drm_fd, connector_id,
1 << j, &cconf))
continue;
test_connector(test_name, &cconf, flags);
kmstest_free_connector_config(&cconf);
}
}
drmModeFreeResources(resources);
return 1;
}
static void clean_up_drm(struct exynos_drm *d, int fd) {
if (d->encoder) drmModeFreeEncoder(d->encoder);
if (d->connector) drmModeFreeConnector(d->connector);
if (d->resources) drmModeFreeResources(d->resources);
free(d);
close(fd);
}
static uint32_t
get_drm_connector_type(struct udev_device *drm_device, uint32_t connector_id)
{
const char *filename;
int fd, i, connector_type;
drmModeResPtr res;
drmModeConnectorPtr connector;
filename = udev_device_get_devnode(drm_device);
fd = open(filename, O_RDWR | O_CLOEXEC);
if (fd < 0) {
printf("couldn't open drm_device\n");
return -1;
}
res = drmModeGetResources(fd);
if (res == 0) {
printf("Failed to get resources from card\n");
close(fd);
return -1;
}
for (i = 0; i < res->count_connectors; i++) {
connector = drmModeGetConnector(fd, res->connectors[i]);
if (!connector)
continue;
if ((connector->connection == DRM_MODE_DISCONNECTED) ||
(connector->connector_id != connector_id)) {
drmModeFreeConnector(connector);
continue;
}
connector_type = connector->connector_type;
drmModeFreeConnector(connector);
drmModeFreeResources(res);
close(fd);
return connector_type;
}
close(fd);
drmModeFreeResources(res);
return -1;
}
bool CDRMUtils::InitDrm()
{
if(m_fd >= 0)
{
/* caps need to be set before allocating connectors, encoders, crtcs, and planes */
auto ret = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
if (ret)
{
CLog::Log(LOGERROR, "CDRMUtils::%s - failed to set Universal planes capability: %s", __FUNCTION__, strerror(errno));
return false;
}
if(!GetResources())
{
return false;
}
if(!GetConnector())
{
return false;
}
if(!GetEncoder())
{
return false;
}
if(!GetCrtc())
{
return false;
}
if(!GetPlanes())
{
return false;
}
}
drmModeFreeResources(m_drm_resources);
m_drm_resources = nullptr;
if(m_fd < 0)
{
return false;
}
if(!GetPreferredMode())
{
return false;
}
drmSetMaster(m_fd);
m_orig_crtc = drmModeGetCrtc(m_fd, m_crtc->crtc->crtc_id);
return true;
}
/**
* Update the resource, required after `blueshift_drm_open_card`
*
* @param connection The identifier for the connection to the card
*/
void blueshift_drm_update_card(int connection)
{
card_connection* card = card_connections + connection;
if (card->res)
drmModeFreeResources(card->res);
card->res = drmModeGetResources(card->fd);
}
bool swc_drm_create_screens(struct wl_list * screens)
{
drmModeRes * resources;
drmModeConnector * connector;
uint32_t index;
struct swc_output * output;
uint32_t taken_crtcs = 0;
if (!(resources = drmModeGetResources(swc.drm->fd)))
{
ERROR("Could not get DRM resources\n");
return false;
}
for (index = 0; index < resources->count_connectors;
++index, drmModeFreeConnector(connector))
{
connector = drmModeGetConnector(swc.drm->fd,
resources->connectors[index]);
if (connector->connection == DRM_MODE_CONNECTED)
{
uint32_t crtc_index;
uint32_t id;
if (!find_available_crtc(resources, connector, taken_crtcs,
&crtc_index))
{
WARNING("Could not find CRTC for connector %u\n", index);
continue;
}
if (!find_available_id(&id))
{
WARNING("No more available output IDs\n");
drmModeFreeConnector(connector);
break;
}
if (!(output = swc_output_new(connector)))
continue;
output->screen = screen_new(resources->crtcs[crtc_index], output);
output->screen->id = id;
taken_crtcs |= 1 << crtc_index;
drm.taken_ids |= 1 << id;
wl_list_insert(screens, &output->screen->link);
}
}
drmModeFreeResources(resources);
return true;
}
/*!***********************************************************************
@Function OsReleaseOS
@description Destroys main window
*************************************************************************/
void PVRShellInit::OsReleaseOS()
{
gbm_surface_destroy(m_psGbmSurface);
gbm_device_destroy(m_psGbmDev);
drmModeFreeCrtc(m_psDrmCrtc);
drmModeFreeEncoder(m_psDrmEncoder);
drmModeFreeConnector(m_psDrmConnector);
drmModeFreeResources(m_psDrmResources);
drmClose(m_i32DrmFile);
}
drmModeConnectorPtr
IntelHWComposerDrm::getConnector(int disp)
{
if (mDrmFd < 0) {
ALOGE("%s: invalid drm FD\n", __func__);
return NULL;
}
uint32_t req_connector_type = 0;
uint32_t req_connector_type_id = 1;
switch (disp) {
case OUTPUT_MIPI0:
case OUTPUT_MIPI1:
req_connector_type = DRM_MODE_CONNECTOR_MIPI;
req_connector_type_id = disp ? 2 : 1;
break;
case OUTPUT_HDMI:
req_connector_type = DRM_MODE_CONNECTOR_DVID;
break;
default:
ALOGW("%s: invalid device number: %d\n", __func__, disp);
return NULL;
}
drmModeResPtr resources = drmModeGetResources(mDrmFd);
if (!resources || !resources->connectors) {
ALOGE("%s: fail to get drm resources. %s\n", __func__, strerror(errno));
return NULL;
}
drmModeConnectorPtr connector = NULL;
// get requested connector type and id
// search connector
for (int i = 0; i < resources->count_connectors; i++) {
connector = drmModeGetConnector(mDrmFd, resources->connectors[i]);
if (!connector) {
ALOGW("%s: fail to get drm connector\n", __func__);
continue;
}
if (connector->connector_type == req_connector_type &&
connector->connector_type_id == req_connector_type_id)
break;
drmModeFreeConnector(connector);
connector = NULL;
}
drmModeFreeResources(resources);
if (connector == NULL)
ALOGW("%s: fail to get required connector\n", __func__);
return connector;
}
static int check_outputs(int fd)
{
drmModeResPtr res = drmModeGetResources(fd);
int ret;
if (!res)
return FALSE;
ret = res->count_connectors > 0;
drmModeFreeResources(res);
return ret;
}
static int modeset_prepare(int fd)
{
drmModeRes *res;
drmModeConnector *conn;
unsigned int i;
struct modeset_dev *dev;
int ret;
/* retrieve resources */
res = drmModeGetResources(fd);
if (!res) {
fprintf(stderr, "cannot retrieve DRM resources (%d): %m\n",
errno);
return -errno;
}
/* iterate all connectors */
for (i = 0; i < res->count_connectors; ++i) {
/* get information for each connector */
conn = drmModeGetConnector(fd, res->connectors[i]);
if (!conn) {
fprintf(stderr, "cannot retrieve DRM connector %u:%u (%d): %m\n",
i, res->connectors[i], errno);
continue;
}
/* create a device structure */
dev = malloc(sizeof(*dev));
memset(dev, 0, sizeof(*dev));
dev->conn = conn->connector_id;
/* call helper function to prepare this connector */
ret = modeset_setup_dev(fd, res, conn, dev);
if (ret) {
if (ret != -ENOENT) {
errno = -ret;
fprintf(stderr, "cannot setup device for connector %u:%u (%d): %m\n",
i, res->connectors[i], errno);
}
free(dev);
drmModeFreeConnector(conn);
continue;
}
/* free connector data and link device into global list */
drmModeFreeConnector(conn);
dev->next = modeset_list;
modeset_list = dev;
}
/* free resources again */
drmModeFreeResources(res);
return 0;
}
static void teardown_drm(void)
{
int i;
drm_intel_bufmgr_destroy(drm.bufmgr);
for (i = 0; i < drm.res->count_connectors; i++)
drmModeFreeConnector(drm.connectors[i]);
drmModeFreeResources(drm.res);
close(drm.fd);
}
static void printResources(int fd) {
drmModeRes *res;
res = drmModeGetResources(fd);
if (!res) {
fprintf(stdout, "cannot retrieve DRM resources (%d): %m\n", errno);
return;
}
printResources0(fd, res);
drmModeFreeResources(res);
}
void QKmsScreen::initializeScreenMode()
{
//Determine optimal mode for screen
drmModeRes *resources = drmModeGetResources(m_device->fd());
if (!resources)
qFatal("drmModeGetResources failed");
drmModeConnector *connector = drmModeGetConnector(m_device->fd(), m_connectorId);
drmModeModeInfo *mode = 0;
for (int i = 0; i < connector->count_modes; ++i) {
if (connector->modes[i].type & DRM_MODE_TYPE_PREFERRED) {
mode = &connector->modes[i];
break;
}
}
if (!mode)
mode = &builtin_1024x768;
drmModeEncoder *encoder = drmModeGetEncoder(m_device->fd(), connector->encoders[0]);
if (encoder == 0)
qFatal("No encoder for connector.");
int i;
for (i = 0; i < resources->count_crtcs; i++) {
if (encoder->possible_crtcs & (1 << i))
break;
}
if (i == resources->count_crtcs)
qFatal("No usable crtc for encoder.");
m_oldCrtc = drmModeGetCrtc(m_device->fd(), encoder->crtc_id);
m_crtcId = resources->crtcs[i];
m_mode = *mode;
m_geometry = QRect(0, 0, m_mode.hdisplay, m_mode.vdisplay);
qDebug() << "kms initialized with geometry" << m_geometry;
m_depth = 32;
m_format = QImage::Format_RGB32;
m_physicalSize = QSizeF(connector->mmWidth, connector->mmHeight);
m_gbmSurface = gbm_surface_create(m_device->gbmDevice(),
m_mode.hdisplay, m_mode.vdisplay,
GBM_BO_FORMAT_XRGB8888,
GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
qDebug() << "created gbm surface" << m_gbmSurface << m_mode.hdisplay << m_mode.vdisplay;
//Cleanup
drmModeFreeEncoder(encoder);
drmModeFreeConnector(connector);
drmModeFreeResources(resources);
}
drmModeEncoderPtr
IntelHWComposerDrm::getEncoder(int disp)
{
if (mDrmFd < 0) {
ALOGE("%s: invalid drm FD\n", __func__);
return NULL;
}
uint32_t req_encoder_type = 0;
switch (disp) {
case OUTPUT_MIPI0:
case OUTPUT_MIPI1:
req_encoder_type = DRM_MODE_ENCODER_MIPI;
break;
case OUTPUT_HDMI:
req_encoder_type = DRM_MODE_ENCODER_TMDS;
break;
default:
ALOGW("%s: invalid device number: %d\n", __func__, disp);
return NULL;
}
drmModeResPtr resources = drmModeGetResources(mDrmFd);
if (!resources || !resources->encoders) {
ALOGE("%s: fail to get drm resources. %s\n", __func__, strerror(errno));
return NULL;
}
drmModeEncoderPtr encoder = NULL;
for (int i = 0; i < resources->count_encoders; i++) {
encoder = drmModeGetEncoder(mDrmFd, resources->encoders[i]);
if (!encoder) {
ALOGW("%s: Failed to get encoder\n", __func__);
continue;
}
if (encoder->encoder_type == req_encoder_type)
break;
drmModeFreeEncoder(encoder);
encoder = NULL;
}
drmModeFreeResources(resources);
if (encoder == NULL)
ALOGW("%s: fail to get required encoder\n", __func__);
return encoder;
}
int main(int argc, char *argv[])
{
static const char optstr[] = "D:M:";
int c, args, ret = 0;
char *device = NULL;
char *module = NULL;
while ((c = getopt(argc, argv, optstr)) != -1) {
switch (c) {
case 'D':
device = optarg;
break;
case 'M':
module = optarg;
break;
default:
usage(argv[0]);
break;
}
}
args = argc - optind;
fd = util_open(device, module);
if (fd < 0)
return 1;
res = drmModeGetResources(fd);
if (!res) {
fprintf(stderr, "Failed to get resources: %s\n",
strerror(errno));
ret = 1;
goto done;
}
if (args < 1) {
listAllProperties();
} else if (args == 4) {
ret = setProperty(&argv[optind]);
} else {
usage(argv[0]);
ret = 1;
}
drmModeFreeResources(res);
done:
drmClose(fd);
return ret;
}
static void exit_drm(void)
{
drmModeRes *resources;
int i;
resources = (drmModeRes *)drm.resource_id;
for (i = 0; i < resources->count_connectors; i++) {
drmModeFreeEncoder((drmModeEncoderPtr)drm.encoder[i]);
drmModeFreeConnector(drm.connectors[i]);
}
drmModeFreeResources((drmModeResPtr)drm.resource_id);
drmClose(drm.fd);
return;
}
static void
device_free (Device *device)
{
if (device->resources != NULL)
drmModeFreeResources (device->resources);
if (device->connector != NULL)
drmModeFreeConnector (device->connector);
if (device->crtc != NULL)
drmModeFreeCrtc (device->crtc);
if (device->fd > 0)
close (device->fd);
}
void drm_free(void)
{
if (g_drm_encoder)
drmModeFreeEncoder(g_drm_encoder);
if (g_drm_connector)
drmModeFreeConnector(g_drm_connector);
if (g_drm_resources)
drmModeFreeResources(g_drm_resources);
memset(&g_drm_fds, 0, sizeof(struct pollfd));
memset(&g_drm_evctx, 0, sizeof(drmEventContext));
g_drm_encoder = NULL;
g_drm_connector = NULL;
g_drm_resources = NULL;
}
void QKmsScreen::initializeScreenMode()
{
//Determine optimal mode for screen
drmModeRes *resources = drmModeGetResources(m_device->fd());
if (!resources)
qFatal("drmModeGetResources failed");
drmModeConnector *connector = drmModeGetConnector(m_device->fd(), m_connectorId);
drmModeModeInfo *mode = 0;
if (connector->count_modes > 0)
mode = &connector->modes[0];
else
mode = &builtin_1024x768;
drmModeEncoder *encoder = drmModeGetEncoder(m_device->fd(), connector->encoders[0]);
if (encoder == 0)
qFatal("No encoder for connector.");
int i;
for (i = 0; i < resources->count_crtcs; i++) {
if (encoder->possible_crtcs & (1 << i))
break;
}
if (i == resources->count_crtcs)
qFatal("No usable crtc for encoder.");
m_crtcId = resources->crtcs[i];
m_mode = *mode;
m_geometry = QRect(0, 0, m_mode.hdisplay, m_mode.vdisplay);
m_depth = 32;
m_format = QImage::Format_RGB32;
m_physicalSize = QSizeF(connector->mmWidth, connector->mmHeight);
//Setup three buffers for current mode
m_bufferManager.setupBuffersForMode(m_mode, 3);
//Set the Mode of the screen.
int ret = drmModeSetCrtc(m_device->fd(), m_crtcId, m_bufferManager.displayFramebufferId(),
0, 0, &m_connectorId, 1, &m_mode);
if (ret)
qFatal("failed to set mode");
//Cleanup
drmModeFreeEncoder(encoder);
drmModeFreeConnector(connector);
drmModeFreeResources(resources);
}
void
drm_display_fini_modeset(struct native_display *ndpy)
{
struct drm_display *drmdpy = drm_display(ndpy);
int i;
if (drmdpy->connectors) {
for (i = 0; i < drmdpy->num_connectors; i++) {
struct drm_connector *drmconn = &drmdpy->connectors[i];
if (drmconn->connector) {
drmModeFreeConnector(drmconn->connector);
FREE(drmconn->drm_modes);
}
}
FREE(drmdpy->connectors);
}
if (drmdpy->shown_surfaces) {
FREE(drmdpy->shown_surfaces);
drmdpy->shown_surfaces = NULL;
}
if (drmdpy->saved_crtcs) {
for (i = 0; i < drmdpy->resources->count_crtcs; i++) {
struct drm_crtc *drmcrtc = &drmdpy->saved_crtcs[i];
if (drmcrtc->crtc) {
/* restore crtc */
drmModeSetCrtc(drmdpy->fd, drmcrtc->crtc->crtc_id,
drmcrtc->crtc->buffer_id, drmcrtc->crtc->x, drmcrtc->crtc->y,
drmcrtc->connectors, drmcrtc->num_connectors,
&drmcrtc->crtc->mode);
drmModeFreeCrtc(drmcrtc->crtc);
}
}
FREE(drmdpy->saved_crtcs);
}
if (drmdpy->resources) {
drmModeFreeResources(drmdpy->resources);
drmdpy->resources = NULL;
}
drmdpy->base.modeset = NULL;
}
void
xorg_crtc_init(ScrnInfoPtr pScrn)
{
modesettingPtr ms = modesettingPTR(pScrn);
xf86CrtcPtr crtc;
drmModeResPtr res;
drmModeCrtcPtr drm_crtc = NULL;
struct crtc_private *crtcp;
int c;
res = drmModeGetResources(ms->fd);
if (res == 0) {
ErrorF("Failed drmModeGetResources %d\n", errno);
return;
}
for (c = 0; c < res->count_crtcs; c++) {
drm_crtc = drmModeGetCrtc(ms->fd, res->crtcs[c]);
if (!drm_crtc)
continue;
crtc = xf86CrtcCreate(pScrn, &crtc_funcs);
if (crtc == NULL)
goto out;
crtcp = calloc(1, sizeof(struct crtc_private));
if (!crtcp) {
xf86CrtcDestroy(crtc);
goto out;
}
crtcp->drm_crtc = drm_crtc;
crtcp->entry.pixmap = NULL;
WSBMINITLISTHEAD(&crtcp->entry.scanout_head);
crtc->driver_private = crtcp;
}
out:
drmModeFreeResources(res);
}
/*
* Initialize KMS.
*/
int gralloc_drm_init_kms(struct gralloc_drm_t *drm)
{
int i;
if (drm->resources)
return 0;
drm->resources = drmModeGetResources(drm->fd);
if (!drm->resources) {
LOGE("failed to get modeset resources");
return -EINVAL;
}
/* find the crtc/connector/mode to use */
for (i = 0; i < drm->resources->count_connectors; i++) {
drmModeConnectorPtr connector;
connector = drmModeGetConnector(drm->fd,
drm->resources->connectors[i]);
if (connector) {
if (connector->connection == DRM_MODE_CONNECTED) {
if (!drm_kms_init_with_connector(drm,
connector))
break;
}
drmModeFreeConnector(connector);
}
}
if (i == drm->resources->count_connectors) {
LOGE("failed to find a valid crtc/connector/mode combination");
drmModeFreeResources(drm->resources);
drm->resources = NULL;
return -EINVAL;
}
drm_kms_init_features(drm);
drm->first_post = 1;
return 0;
}
static DFBResult
system_shutdown( bool emergency )
{
MesaDataShared *shared;
D_ASSERT( m_data != NULL );
shared = m_data->shared;
D_ASSERT( shared != NULL );
dfb_surface_pool_destroy( shared->pool );
if (m_data->saved_crtc) {
drmModeSetCrtc( m_data->fd, m_data->saved_crtc->crtc_id, m_data->saved_crtc->buffer_id, m_data->saved_crtc->x,
m_data->saved_crtc->y, &m_data->connector->connector_id, 1, &m_data->saved_crtc->mode );
drmModeFreeCrtc( m_data->saved_crtc );
}
/* cleanup EGL related stuff */
eglMakeCurrent( m_data->dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
eglDestroyContext( m_data->dpy, m_data->ctx );
eglTerminate( m_data->dpy );
if (m_data->resources)
drmModeFreeResources( m_data->resources );
gbm_device_destroy( m_data->gbm );
/* close drm fd */
close( m_data->fd );
if (dfb_config->vt)
dfb_vt_shutdown( emergency );
SHFREE( shared->shmpool, shared );
D_FREE( m_data );
m_data = NULL;
return DFB_OK;
}
/**
* Close connection to the graphics card
*
* @param connection The identifier for the connection to the card
*/
void blueshift_drm_close_card(int connection)
{
card_connection* card = card_connections + connection;
drmModeFreeResources(card->res);
if (card->connectors)
free(card->connectors);
close(card->fd);
if ((size_t)connection + 1 == card_connection_reuse_ptr)
card_connection_reuse_ptr--;
else
{
if (card_connection_reuse_size == 0)
card_connection_reusables = malloc((card_connection_reuse_size = 8) * sizeof(long));
else if (card_connection_reuse_ptr == card_connection_reuse_size)
card_connection_reusables = realloc(card_connection_reusables, (card_connection_reuse_size <<= 1) * sizeof(long));
*(card_connection_reusables + card_connection_reuse_ptr++) = connection;
}
}
