static int rcar_du_hdmi_connector_get_modes(struct drm_connector *connector)
{
int count = 0;
struct drm_encoder *encoder = connector_to_encoder(connector);
if (to_encoder_slave(encoder)->slave_funcs &&
to_encoder_slave(encoder)->slave_funcs->get_modes)
count += to_encoder_slave(encoder)->slave_funcs->get_modes(
encoder, connector);
else
return -EIO;
return count;
}
static enum drm_connector_status
rcar_du_hdmi_connector_detect(struct drm_connector *connector, bool force)
{
enum drm_connector_status status = connector_status_unknown;
struct drm_encoder *encoder = connector_to_encoder(connector);
if (to_encoder_slave(encoder)->slave_funcs &&
to_encoder_slave(encoder)->slave_funcs->detect)
status =
to_encoder_slave(encoder)->slave_funcs->detect(
encoder, connector);
return status;
}
/**
* drm_i2c_encoder_destroy - Unregister the I2C device backing an encoder
* @drm_encoder: Encoder to be unregistered.
*
* This should be called from the @destroy method of an I2C slave
* encoder driver once I2C access is no longer needed.
*/
void drm_i2c_encoder_destroy(struct drm_encoder *drm_encoder)
{
struct drm_encoder_slave *encoder = to_encoder_slave(drm_encoder);
struct i2c_client *client = drm_i2c_encoder_get_client(drm_encoder);
struct module *module = client->driver->driver.owner;
i2c_unregister_device(client);
encoder->bus_priv = NULL;
module_put(module);
}
static void ch7006_encoder_destroy(struct drm_encoder *encoder)
{
struct ch7006_priv *priv = to_ch7006_priv(encoder);
drm_property_destroy(encoder->dev, priv->scale_property);
kfree(priv);
to_encoder_slave(encoder)->slave_priv = NULL;
drm_i2c_encoder_destroy(encoder);
}
static int armada_drm_slave_get_modes(struct drm_connector *conn)
{
struct drm_encoder *enc = armada_drm_connector_encoder(conn);
int count = 0;
if (enc) {
struct drm_encoder_slave *slave = to_encoder_slave(enc);
count = slave->slave_funcs->get_modes(enc, conn);
}
return count;
}
static void armada_drm_slave_destroy(struct drm_encoder *enc)
{
struct drm_encoder_slave *slave = to_encoder_slave(enc);
struct i2c_client *client = drm_i2c_encoder_get_client(enc);
if (slave->slave_funcs)
slave->slave_funcs->destroy(enc);
if (client)
i2c_put_adapter(client->adapter);
drm_encoder_cleanup(&slave->base);
kfree(slave);
}
/* destroy encoder */
void xilinx_drm_encoder_destroy(struct drm_encoder *base_encoder)
{
struct xilinx_drm_encoder *encoder;
struct drm_encoder_slave *encoder_slave;
encoder_slave = to_encoder_slave(base_encoder);
encoder = to_xilinx_encoder(encoder_slave);
/* make sure encoder is off */
xilinx_drm_encoder_dpms(base_encoder, DRM_MODE_DPMS_OFF);
drm_encoder_cleanup(base_encoder);
put_device(encoder->dev);
}
int
nv04_tv_create(struct drm_connector *connector, struct dcb_output *entry)
{
struct nouveau_encoder *nv_encoder;
struct drm_encoder *encoder;
struct drm_device *dev = connector->dev;
struct nouveau_drm *drm = nouveau_drm(dev);
struct nvkm_i2c *i2c = nvxx_i2c(&drm->device);
struct nvkm_i2c_port *port = i2c->find(i2c, entry->i2c_index);
int type, ret;
/* Ensure that we can talk to this encoder */
type = nv04_tv_identify(dev, entry->i2c_index);
if (type < 0)
return type;
/* Allocate the necessary memory */
nv_encoder = kzalloc(sizeof(*nv_encoder), GFP_KERNEL);
if (!nv_encoder)
return -ENOMEM;
/* Initialize the common members */
encoder = to_drm_encoder(nv_encoder);
drm_encoder_init(dev, encoder, &nv04_tv_funcs, DRM_MODE_ENCODER_TVDAC);
drm_encoder_helper_add(encoder, &nv04_tv_helper_funcs);
encoder->possible_crtcs = entry->heads;
encoder->possible_clones = 0;
nv_encoder->dcb = entry;
nv_encoder->or = ffs(entry->or) - 1;
/* Run the slave-specific initialization */
ret = drm_i2c_encoder_init(dev, to_encoder_slave(encoder),
&port->adapter,
&nv04_tv_encoder_info[type].dev);
if (ret < 0)
goto fail_cleanup;
/* Attach it to the specified connector. */
get_slave_funcs(encoder)->create_resources(encoder, connector);
drm_mode_connector_attach_encoder(connector, encoder);
return 0;
fail_cleanup:
drm_encoder_cleanup(encoder);
kfree(nv_encoder);
return ret;
}
/* get mode list */
static int xilinx_drm_connector_get_modes(struct drm_connector *base_connector)
{
struct xilinx_drm_connector *connector =
to_xilinx_connector(base_connector);
struct drm_encoder *encoder = connector->encoder;
struct drm_encoder_slave *encoder_slave = to_encoder_slave(encoder);
const struct drm_encoder_slave_funcs *encoder_sfuncs =
encoder_slave->slave_funcs;
int count = 0;
if (encoder_sfuncs->get_modes)
count = encoder_sfuncs->get_modes(encoder, base_connector);
return count;
}
/* check if mode is valid */
static int xilinx_drm_connector_mode_valid(struct drm_connector *base_connector,
struct drm_display_mode *mode)
{
struct xilinx_drm_connector *connector =
to_xilinx_connector(base_connector);
struct drm_encoder *encoder = connector->encoder;
struct drm_encoder_slave *encoder_slave = to_encoder_slave(encoder);
const struct drm_encoder_slave_funcs *encoder_sfuncs =
encoder_slave->slave_funcs;
int ret = MODE_OK;
if (encoder_sfuncs->mode_valid)
ret = encoder_sfuncs->mode_valid(encoder, mode);
return ret;
}
/* adjust a mode if needed */
static bool
xilinx_drm_encoder_mode_fixup(struct drm_encoder *base_encoder,
const struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
struct drm_encoder_slave *encoder_slave;
const struct drm_encoder_slave_funcs *encoder_sfuncs = NULL;
bool ret = true;
encoder_slave = to_encoder_slave(base_encoder);
encoder_sfuncs = encoder_slave->slave_funcs;
if (encoder_sfuncs->mode_fixup)
ret = encoder_sfuncs->mode_fixup(base_encoder, mode,
adjusted_mode);
return ret;
}
/* set mode to xilinx encoder */
static void xilinx_drm_encoder_mode_set(struct drm_encoder *base_encoder,
struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
struct drm_encoder_slave *encoder_slave;
const struct drm_encoder_slave_funcs *encoder_sfuncs;
DRM_DEBUG_KMS("h: %d, v: %d\n",
adjusted_mode->hdisplay, adjusted_mode->vdisplay);
DRM_DEBUG_KMS("refresh: %d, pclock: %d khz\n",
adjusted_mode->vrefresh, adjusted_mode->clock);
encoder_slave = to_encoder_slave(base_encoder);
encoder_sfuncs = encoder_slave->slave_funcs;
if (encoder_sfuncs->mode_set)
encoder_sfuncs->mode_set(base_encoder, mode, adjusted_mode);
}
/* set encoder dpms */
static void xilinx_drm_encoder_dpms(struct drm_encoder *base_encoder, int dpms)
{
struct xilinx_drm_encoder *encoder;
struct drm_encoder_slave *encoder_slave;
const struct drm_encoder_slave_funcs *encoder_sfuncs;
encoder_slave = to_encoder_slave(base_encoder);
encoder_sfuncs = encoder_slave->slave_funcs;
encoder = to_xilinx_encoder(encoder_slave);
DRM_DEBUG_KMS("dpms: %d -> %d\n", encoder->dpms, dpms);
if (encoder->dpms == dpms)
return;
encoder->dpms = dpms;
if (encoder_sfuncs->dpms)
encoder_sfuncs->dpms(base_encoder, dpms);
}
static enum drm_connector_status
xylon_drm_connector_detect(struct drm_connector *base_connector, bool force)
{
struct xylon_drm_connector *connector =
to_xylon_connector(base_connector);
enum drm_connector_status status = connector_status_unknown;
struct drm_encoder *encoder = connector->encoder;
struct drm_encoder_slave *encoder_slave = to_encoder_slave(encoder);
struct drm_encoder_slave_funcs *encoder_sfuncs =
encoder_slave->slave_funcs;
if (encoder_sfuncs->detect)
status = encoder_sfuncs->detect(encoder, base_connector);
if (force && (status != connector_status_connected))
status = encoder_sfuncs->detect(encoder, base_connector);
return status;
}
static enum drm_connector_status
xilinx_drm_connector_detect(struct drm_connector *base_connector, bool force)
{
struct xilinx_drm_connector *connector =
to_xilinx_connector(base_connector);
enum drm_connector_status status = connector_status_unknown;
struct drm_encoder *encoder = connector->encoder;
struct drm_encoder_slave *encoder_slave = to_encoder_slave(encoder);
const struct drm_encoder_slave_funcs *encoder_sfuncs =
encoder_slave->slave_funcs;
if (encoder_sfuncs->detect)
status = encoder_sfuncs->detect(encoder, base_connector);
/* some connector ignores the first hpd, so try again if forced */
if (force && (status != connector_status_connected))
status = encoder_sfuncs->detect(encoder, base_connector);
DRM_DEBUG_KMS("status: %d\n", status);
return status;
}
static struct adv7511 *encoder_to_adv7511(struct drm_encoder *encoder)
{
return to_encoder_slave(encoder)->slave_priv;
}
static inline struct xilinx_drm_dp *to_dp(struct drm_encoder *encoder)
{
return to_encoder_slave(encoder)->slave_priv;
}
static inline struct drm_encoder_slave_funcs *
get_slave_funcs(struct drm_encoder *enc)
{
return to_encoder_slave(enc)->slave_funcs;
}
