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