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