static int platform_match(struct device *dev, struct device_driver *drv)
{
struct platform_device *pdev = to_platform_device(dev);
struct platform_driver *pdrv = to_platform_driver(drv);
return (strcmp(pdev->name, drv->name));
}
static int platform_drv_probe(struct device *_dev)
{
struct platform_driver *drv = to_platform_driver(_dev->driver);
struct platform_device *dev = to_platform_device(_dev);
return drv->probe(dev);
}
static int platform_drv_probe(struct device *_dev)
{
struct platform_driver *drv = to_platform_driver(_dev->driver);
struct platform_device *dev = to_platform_device(_dev);
int ret;
ret = of_clk_set_defaults(_dev->of_node, false);
if (ret < 0)
return ret;
ret = dev_pm_domain_attach(_dev, true);
if (ret)
goto out;
if (drv->probe) {
ret = drv->probe(dev);
if (ret)
dev_pm_domain_detach(_dev, true);
}
out:
if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) {
dev_warn(_dev, "probe deferral not supported\n");
ret = -ENXIO;
}
return ret;
}
static void disable_dss(void)
{
struct device *dev;
struct platform_device *plat_dev;
struct device_driver *drv;
struct platform_driver *plat_drv;
pm_message_t pt;
dev = device_find_child(&platform_bus, "omapdss", find_my_dev);
if (!dev)
{
printk("Could not find omapdss device\n");
return;
}
drv = dev->driver;
if (!drv)
{
printk("Could not find omapdss driver\n");
return;
}
plat_drv = to_platform_driver(drv);
plat_dev = to_platform_device(dev);
if (!plat_drv->suspend)
{
printk("Could not find suspend in omapdss driver\n");
return;
}
pt.event = 0;
plat_drv->suspend(plat_dev, pt);
}
static void platform_drv_shutdown(struct device *_dev)
{
struct platform_driver *drv = to_platform_driver(_dev->driver);
struct platform_device *dev = to_platform_device(_dev);
if (drv->shutdown)
drv->shutdown(dev);
}
static int platform_legacy_resume(struct device *dev)
{
struct platform_driver *pdrv = to_platform_driver(dev->driver);
struct platform_device *pdev = to_platform_device(dev);
int ret = 0;
if (dev->driver && pdrv->resume)
ret = pdrv->resume(pdev);
return ret;
}
static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
{
struct platform_driver *pdrv = to_platform_driver(dev->driver);
struct platform_device *pdev = to_platform_device(dev);
int ret = 0;
if (dev->driver && pdrv->suspend)
ret = pdrv->suspend(pdev, mesg);
return ret;
}
static int platform_drv_remove(struct device *_dev)
{
struct platform_driver *drv = to_platform_driver(_dev->driver);
struct platform_device *dev = to_platform_device(_dev);
int ret = 0;
if (drv->remove)
ret = drv->remove(dev);
dev_pm_domain_detach(_dev, true);
return ret;
}
/**
* platform_match - bind platform device to platform driver.
* @dev: device.
* @drv: driver.
*
* Platform device IDs are assumed to be encoded like this:
* "<name><instance>", where <name> is a short description of the type of
* device, like "pci" or "floppy", and <instance> is the enumerated
* instance of the device, like '0' or '42'. Driver IDs are simply
* "<name>". So, extract the <name> from the platform_device structure,
* and compare it against the name of the driver. Return whether they match
* or not.
*/
static int platform_match(struct device *dev, struct device_driver *drv)
{
struct platform_device *pdev = to_platform_device(dev);
struct platform_driver *pdrv = to_platform_driver(drv);
/* When driver_override is set, only bind to the matching driver */
if (pdev->driver_override)
return !strcmp(pdev->driver_override, drv->name);
/* Attempt an OF style match first */
if (of_driver_match_device(dev, drv))
return 1;
/* Then try ACPI style match */
if (acpi_driver_match_device(dev, drv))
return 1;
/* Then try to match against the id table */
if (pdrv->id_table)
return platform_match_id(pdrv->id_table, pdev) != NULL;
/* fall-back to driver name match */
return (strcmp(pdev->name, drv->name) == 0);
}
/* create encoder */
struct drm_encoder *xilinx_drm_encoder_create(struct drm_device *drm,
struct device_node *node)
{
struct xilinx_drm_encoder *encoder;
struct i2c_client *i2c_slv;
struct i2c_driver *i2c_driver;
struct drm_i2c_encoder_driver *drm_i2c_driver;
struct device_driver *device_driver;
struct platform_device *platform_slv;
struct platform_driver *platform_driver;
struct drm_platform_encoder_driver *drm_platform_driver;
int ret = 0;
encoder = devm_kzalloc(drm->dev, sizeof(*encoder), GFP_KERNEL);
if (!encoder)
return ERR_PTR(-ENOMEM);
encoder->dpms = DRM_MODE_DPMS_OFF;
/* FIXME: Use DT to figure out crtcs / clones */
encoder->slave.base.possible_crtcs = 1;
encoder->slave.base.possible_clones = ~0;
ret = drm_encoder_init(drm, &encoder->slave.base,
&xilinx_drm_encoder_funcs,
DRM_MODE_ENCODER_TMDS, NULL);
if (ret) {
DRM_ERROR("failed to initialize drm encoder\n");
return ERR_PTR(ret);
}
drm_encoder_helper_add(&encoder->slave.base,
&xilinx_drm_encoder_helper_funcs);
/* initialize slave encoder */
i2c_slv = of_find_i2c_device_by_node(node);
if (i2c_slv && i2c_slv->dev.driver) {
i2c_driver = to_i2c_driver(i2c_slv->dev.driver);
drm_i2c_driver = to_drm_i2c_encoder_driver(i2c_driver);
if (!drm_i2c_driver) {
DRM_ERROR("failed to initialize i2c slave\n");
ret = -EPROBE_DEFER;
goto err_out;
}
encoder->dev = &i2c_slv->dev;
ret = drm_i2c_driver->encoder_init(i2c_slv, drm,
&encoder->slave);
} else {
platform_slv = of_find_device_by_node(node);
if (!platform_slv) {
DRM_DEBUG_KMS("failed to get an encoder slv\n");
return ERR_PTR(-EPROBE_DEFER);
}
device_driver = platform_slv->dev.driver;
if (!device_driver) {
DRM_DEBUG_KMS("failed to get device driver\n");
return ERR_PTR(-EPROBE_DEFER);
}
platform_driver = to_platform_driver(device_driver);
drm_platform_driver =
to_drm_platform_encoder_driver(platform_driver);
if (!drm_platform_driver) {
DRM_ERROR("failed to initialize platform slave\n");
ret = -EPROBE_DEFER;
goto err_out;
}
encoder->dev = &platform_slv->dev;
ret = drm_platform_driver->encoder_init(platform_slv, drm,
&encoder->slave);
}
if (ret) {
DRM_ERROR("failed to initialize encoder slave\n");
goto err_out;
}
if (!encoder->slave.slave_funcs) {
DRM_ERROR("there's no encoder slave function\n");
ret = -ENODEV;
goto err_out;
}
return &encoder->slave.base;
err_out:
return ERR_PTR(ret);
}
/* create encoder */
struct drm_encoder *xilinx_drm_encoder_create(struct drm_device *drm)
{
struct xilinx_drm_encoder *encoder;
struct device_node *sub_node;
struct i2c_driver *i2c_driver;
struct drm_i2c_encoder_driver *drm_i2c_driver;
struct device_driver *device_driver;
struct platform_driver *platform_driver;
struct drm_platform_encoder_driver *drm_platform_driver;
int ret = 0;
encoder = devm_kzalloc(drm->dev, sizeof(*encoder), GFP_KERNEL);
if (!encoder)
return ERR_PTR(-ENOMEM);
encoder->dpms = DRM_MODE_DPMS_OFF;
/* initialize encoder */
encoder->slave.base.possible_crtcs = 1;
ret = drm_encoder_init(drm, &encoder->slave.base,
&xilinx_drm_encoder_funcs,
DRM_MODE_ENCODER_TMDS);
if (ret) {
DRM_ERROR("failed to initialize drm encoder\n");
return ERR_PTR(ret);
}
drm_encoder_helper_add(&encoder->slave.base,
&xilinx_drm_encoder_helper_funcs);
/* get slave encoder */
sub_node = of_parse_phandle(drm->dev->of_node, "xlnx,encoder-slave", 0);
if (!sub_node) {
DRM_ERROR("failed to get an encoder slave node\n");
return ERR_PTR(-ENODEV);
}
/* initialize slave encoder */
encoder->i2c_slv = of_find_i2c_device_by_node(sub_node);
if (encoder->i2c_slv) {
i2c_driver = to_i2c_driver(encoder->i2c_slv->dev.driver);
drm_i2c_driver = to_drm_i2c_encoder_driver(i2c_driver);
if (!drm_i2c_driver) {
DRM_ERROR("failed to initialize i2c slave\n");
ret = -EPROBE_DEFER;
goto err_out;
}
ret = drm_i2c_driver->encoder_init(encoder->i2c_slv, drm,
&encoder->slave);
} else {
encoder->platform_slv = of_find_device_by_node(sub_node);
if (!encoder->platform_slv) {
DRM_DEBUG_KMS("failed to get an encoder slv\n");
return ERR_PTR(-EPROBE_DEFER);
}
device_driver = encoder->platform_slv->dev.driver;
if (!device_driver) {
DRM_DEBUG_KMS("failed to get device driver\n");
return ERR_PTR(-EPROBE_DEFER);
}
platform_driver = to_platform_driver(device_driver);
drm_platform_driver =
to_drm_platform_encoder_driver(platform_driver);
if (!drm_platform_driver) {
DRM_ERROR("failed to initialize platform slave\n");
ret = -EPROBE_DEFER;
goto err_out;
}
ret = drm_platform_driver->encoder_init(encoder->platform_slv,
drm,
&encoder->slave);
}
of_node_put(sub_node);
if (ret) {
DRM_ERROR("failed to initialize encoder slave\n");
goto err_out;
}
if (!encoder->slave.slave_funcs) {
DRM_ERROR("there's no encoder slave function\n");
ret = -ENODEV;
goto err_out;
}
return &encoder->slave.base;
err_out:
return ERR_PTR(ret);
}
