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; } }