bool drm_mipi_setMode(int mode) { drmModeConnector *connector = getConnector(gDrmCxt.drmFD, DRM_MODE_CONNECTOR_MIPI); if (connector == NULL) return false; int i = 0; drmModePropertyPtr props = NULL; // Set MIPI On/Off for (i = 0; i < connector->count_props; i++) { props = drmModeGetProperty(gDrmCxt.drmFD, connector->props[i]); if (!props) continue; if (props->name != NULL && !strncmp(props->name, "DPMS", sizeof("DPMS"))) { LOGV("%s: %s %u", __func__, (mode == DRM_MIPI_ON) ? "On" : "Off", connector->connector_id); drmModeConnectorSetProperty(gDrmCxt.drmFD, connector->connector_id, props->prop_id, (mode == DRM_MIPI_ON) ? DRM_MODE_DPMS_ON : DRM_MODE_DPMS_OFF); drmModeFreeProperty(props); break; } drmModeFreeProperty(props); } drmModeFreeConnector(connector); return true; }
static void drmmode_output_dpms(xf86OutputPtr output, int mode) { drmmode_output_private_ptr drmmode_output = output->driver_private; drmModeConnectorPtr koutput = drmmode_output->mode_output; drmmode_ptr drmmode = drmmode_output->drmmode; int i; drmModePropertyPtr props; for (i = 0; i < koutput->count_props; i++) { props = drmModeGetProperty(drmmode->fd, koutput->props[i]); if (!props) continue; if (!strcmp(props->name, "DPMS")) { drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id, props->prop_id, mode); drmmode_output_dpms_backlight(output, drmmode_output->dpms_mode, mode); drmmode_output->dpms_mode = mode; drmModeFreeProperty(props); return; } drmModeFreeProperty(props); } }
void mgm::RealKMSOutput::set_power_mode(MirPowerMode mode) { std::lock_guard<std::mutex> lg(power_mutex); if (power_mode != mode) { power_mode = mode; drmModeConnectorSetProperty(drm_fd, connector_id, dpms_enum_id, mode); } }
bool Drm::setDpmsMode(int device, int mode) { Mutex::Autolock _l(mLock); int output = getOutputIndex(device); if (output < 0 ) { return false; } if (mode != IDisplayDevice::DEVICE_DISPLAY_OFF && mode != IDisplayDevice::DEVICE_DISPLAY_STANDBY && mode != IDisplayDevice::DEVICE_DISPLAY_ON) { ELOGTRACE("invalid mode %d", mode); return false; } DrmOutput *out = &mOutputs[output]; if (!out->connected) { ELOGTRACE("device is not connected"); return false; } drmModePropertyPtr props; for (int i = 0; i < out->connector->count_props; i++) { props = drmModeGetProperty(mDrmFd, out->connector->props[i]); if (!props) { continue; } if (strcmp(props->name, "DPMS") == 0) { int ret = drmModeConnectorSetProperty( mDrmFd, out->connector->connector_id, props->prop_id, (mode == IDisplayDevice::DEVICE_DISPLAY_ON) ? DRM_MODE_DPMS_ON : IDisplayDevice::DEVICE_DISPLAY_STANDBY == mode ? DRM_MODE_DPMS_STANDBY : DRM_MODE_DPMS_OFF); drmModeFreeProperty(props); if (ret != 0) { ELOGTRACE("unable to set DPMS %d", mode); return false; } else { return true; } } drmModeFreeProperty(props); } return false; }
// DPMS bool IntelHWComposerDrm::setDisplayDpms(int disp, bool blank) { int ret=0; if (disp == OUTPUT_MIPI0) { // Set MIPI On/Off drmModeConnectorPtr connector; drmModePropertyPtr props = NULL; if ((connector = getConnector(disp)) == NULL) { ALOGW("%s: failed to get connector :%d!\n", __func__, disp); goto err; } if (connector->connection != DRM_MODE_CONNECTED) { ALOGW("%s: connector %d is not connected!\n", __func__, disp); freeConnector(connector); goto err; } for (int i = 0; i < connector->count_props; i++) { props = drmModeGetProperty(mDrmFd, connector->props[i]); if (!props) continue; if (!strcmp(props->name, "DPMS")) { ALOGD_IF(ALLOW_MONITOR_PRINT, "%s: %s %u", __func__, (blank == 0) ? "On" : "Off", connector->connector_id); ret = drmModeConnectorSetProperty(mDrmFd, connector->connector_id, props->prop_id, (blank==0) ? DRM_MODE_DPMS_ON : DRM_MODE_DPMS_OFF); drmModeFreeProperty(props); break; } drmModeFreeProperty(props); } } else if (disp == OUTPUT_HDMI) { // Set HDMI On/Off struct drm_psb_disp_ctrl dp_ctrl; ALOGD_IF(ALLOW_MONITOR_PRINT, "%s: %s", __func__, (blank == 0) ? "On" : "Off"); memset(&dp_ctrl, 0, sizeof(dp_ctrl)); dp_ctrl.cmd = (blank==0) ? DRM_PSB_DISP_PLANEB_ENABLE : DRM_PSB_DISP_PLANEB_DISABLE; ret = drmCommandWriteRead(mDrmFd, DRM_PSB_HDMI_FB_CMD, &dp_ctrl, sizeof(dp_ctrl)); } if (ret != 0) { ALOGW("%s: connector %d dpms failed!\n", __func__, disp); goto err; } return true; err: return false; }
static int display_set_dpms(struct uterm_display *disp, int state) { int i, ret, set; drmModeConnector *conn; drmModePropertyRes *prop; if (!display_is_conn(disp) || !video_is_awake(disp->video)) return -EINVAL; switch (state) { case UTERM_DPMS_ON: set = DRM_MODE_DPMS_ON; break; case UTERM_DPMS_STANDBY: set = DRM_MODE_DPMS_STANDBY; break; case UTERM_DPMS_SUSPEND: set = DRM_MODE_DPMS_SUSPEND; break; case UTERM_DPMS_OFF: set = DRM_MODE_DPMS_OFF; break; default: return -EINVAL; } log_info("setting DPMS of display %p to %s", disp, uterm_dpms_to_name(state)); conn = drmModeGetConnector(disp->video->dumb.fd, disp->dumb.conn_id); if (!conn) { log_err("cannot get display connector"); return -EFAULT; } ret = 0; for (i = 0; i < conn->count_props; ++i) { prop = drmModeGetProperty(disp->video->dumb.fd, conn->props[i]); if (!prop) continue; if (!strcmp(prop->name, "DPMS")) { ret = drmModeConnectorSetProperty(disp->video->dumb.fd, disp->dumb.conn_id, prop->prop_id, set); if (ret) { log_info("cannot set DPMS"); ret = -EFAULT; } drmModeFreeProperty(prop); break; } drmModeFreeProperty(prop); } if (i == conn->count_props) { ret = 0; log_warn("display does not support DPMS"); state = UTERM_DPMS_UNKNOWN; } drmModeFreeConnector(conn); disp->dpms = state; return ret; }
static Bool drmmode_output_set_property(xf86OutputPtr output, Atom property, RRPropertyValuePtr value) { drmmode_output_private_ptr drmmode_output = output->driver_private; drmmode_ptr drmmode = drmmode_output->drmmode; int i; if (property == backlight_atom || property == backlight_deprecated_atom) { INT32 val; if (value->type != XA_INTEGER || value->format != 32 || value->size != 1) { return FALSE; } val = *(INT32 *)value->data; if (val < 0 || val > drmmode_output->backlight_max) return FALSE; if (drmmode_output->dpms_mode == DPMSModeOn) drmmode_backlight_set(output, val); drmmode_output->backlight_active_level = val; return TRUE; } for (i = 0; i < drmmode_output->num_props; i++) { drmmode_prop_ptr p = &drmmode_output->props[i]; if (p->atoms[0] != property) continue; if (p->mode_prop->flags & DRM_MODE_PROP_RANGE) { uint32_t val; if (value->type != XA_INTEGER || value->format != 32 || value->size != 1) return FALSE; val = *(uint32_t *)value->data; drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id, p->mode_prop->prop_id, (uint64_t)val); return TRUE; } else if (p->mode_prop->flags & DRM_MODE_PROP_ENUM) { Atom atom; const char *name; int j; if (value->type != XA_ATOM || value->format != 32 || value->size != 1) return FALSE; memcpy(&atom, value->data, 4); name = NameForAtom(atom); /* search for matching name string, then set its value down */ for (j = 0; j < p->mode_prop->count_enums; j++) { if (!strcmp(p->mode_prop->enums[j].name, name)) { drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id, p->mode_prop->prop_id, p->mode_prop->enums[j].value); return TRUE; } } return FALSE; } } return TRUE; }