static int flcn_probe(struct platform_device *dev)
{
int err;
struct nvhost_device_data *pdata = NULL;
if (dev->dev.of_node) {
const struct of_device_id *match;
match = of_match_device(tegra_flcn_of_match, &dev->dev);
if (match)
pdata = (struct nvhost_device_data *)match->data;
} else
pdata = (struct nvhost_device_data *)dev->dev.platform_data;
if (!pdata) {
dev_err(&dev->dev, "no platform data\n");
return -ENODATA;
}
nvhost_dbg_fn("dev:%p pdata:%p", dev, pdata);
pdata->pdev = dev;
mutex_init(&pdata->lock);
platform_set_drvdata(dev, pdata);
err = nvhost_client_device_get_resources(dev);
if (err)
return err;
dev->dev.platform_data = NULL;
nvhost_module_init(dev);
#ifdef CONFIG_PM_GENERIC_DOMAINS
pdata->pd.name = kstrdup(dev->name, GFP_KERNEL);
if (!pdata->pd.name)
return -ENOMEM;
err = nvhost_module_add_domain(&pdata->pd, dev);
#endif
err = nvhost_client_device_init(dev);
if (err) {
nvhost_dbg_fn("failed to init client device for %s",
dev->name);
pm_runtime_put(&dev->dev);
return err;
}
return 0;
}
static int msenc_probe(struct platform_device *dev)
{
int err = 0;
struct nvhost_device_data *pdata = NULL;
if (dev->dev.of_node) {
const struct of_device_id *match;
match = of_match_device(tegra_msenc_of_match, &dev->dev);
if (match)
pdata = (struct nvhost_device_data *)match->data;
} else
pdata = (struct nvhost_device_data *)dev->dev.platform_data;
WARN_ON(!pdata);
if (!pdata) {
dev_info(&dev->dev, "no platform data\n");
return -ENODATA;
}
pdata->pdev = dev;
mutex_init(&pdata->lock);
platform_set_drvdata(dev, pdata);
err = nvhost_client_device_get_resources(dev);
if (err)
return err;
dev->dev.platform_data = NULL;
/* get the module clocks to sane state */
nvhost_module_init(dev);
#ifdef CONFIG_PM_GENERIC_DOMAINS
pdata->pd.name = "msenc";
/* add module power domain and also add its domain
* as sub-domain of MC domain */
err = nvhost_module_add_domain(&pdata->pd, dev);
#endif
err = nvhost_client_device_init(dev);
return 0;
}
static int gr3d_probe(struct platform_device *dev)
{
int err = 0;
struct nvhost_device_data *pdata = NULL;
if (dev->dev.of_node) {
const struct of_device_id *match;
match = of_match_device(tegra_gr3d_of_match, &dev->dev);
if (match)
pdata = (struct nvhost_device_data *)match->data;
} else
pdata = (struct nvhost_device_data *)dev->dev.platform_data;
WARN_ON(!pdata);
if (!pdata) {
dev_info(&dev->dev, "no platform data\n");
return -ENODATA;
}
pdata->pdev = dev;
mutex_init(&pdata->lock);
platform_set_drvdata(dev, pdata);
err = nvhost_client_device_get_resources(dev);
if (err)
return err;
nvhost_module_init(dev);
#ifdef CONFIG_PM_GENERIC_DOMAINS
pdata->pd.name = "gr3d";
err = nvhost_module_add_domain(&pdata->pd, dev);
#endif
err = nvhost_client_device_init(dev);
return err;
}
static int __devinit nvhost_probe(struct nvhost_device *dev,
struct nvhost_device_id *id_table)
{
struct nvhost_master *host;
struct resource *regs, *intr0, *intr1;
int i, err;
regs = nvhost_get_resource(dev, IORESOURCE_MEM, 0);
intr0 = nvhost_get_resource(dev, IORESOURCE_IRQ, 0);
intr1 = nvhost_get_resource(dev, IORESOURCE_IRQ, 1);
if (!regs || !intr0 || !intr1) {
dev_err(&dev->dev, "missing required platform resources\n");
return -ENXIO;
}
host = kzalloc(sizeof(*host), GFP_KERNEL);
if (!host)
return -ENOMEM;
/* Register host1x device as bus master */
host->dev = dev;
/* Copy host1x parameters */
memcpy(&host->info, dev->dev.platform_data,
sizeof(struct host1x_device_info));
host->reg_mem = request_mem_region(regs->start,
resource_size(regs), dev->name);
if (!host->reg_mem) {
dev_err(&dev->dev, "failed to get host register memory\n");
err = -ENXIO;
goto fail;
}
host->aperture = ioremap(regs->start, resource_size(regs));
if (!host->aperture) {
dev_err(&dev->dev, "failed to remap host registers\n");
err = -ENXIO;
goto fail;
}
err = nvhost_alloc_resources(host);
if (err) {
dev_err(&dev->dev, "failed to init chip support\n");
goto fail;
}
host->memmgr = mem_op().alloc_mgr();
if (!host->memmgr) {
dev_err(&dev->dev, "unable to create nvmap client\n");
err = -EIO;
goto fail;
}
/* Register host1x device as bus master */
host->dev = dev;
/* Give pointer to host1x via driver */
nvhost_set_drvdata(dev, host);
nvhost_bus_add_host(host);
err = nvhost_syncpt_init(dev, &host->syncpt);
if (err)
goto fail;
err = nvhost_intr_init(&host->intr, intr1->start, intr0->start);
if (err)
goto fail;
err = nvhost_user_init(host);
if (err)
goto fail;
err = nvhost_module_init(dev);
if (err)
goto fail;
for (i = 0; i < host->dev->num_clks; i++)
clk_enable(host->dev->clk[i]);
nvhost_syncpt_reset(&host->syncpt);
for (i = 0; i < host->dev->num_clks; i++)
clk_disable(host->dev->clk[0]);
nvhost_debug_init(host);
dev_info(&dev->dev, "initialized\n");
return 0;
fail:
nvhost_free_resources(host);
if (host->memmgr)
mem_op().put_mgr(host->memmgr);
kfree(host);
return err;
}
static int vi_probe(struct platform_device *dev)
{
int err = 0;
struct vi *tegra_vi;
struct nvhost_device_data *pdata = NULL;
if (dev->dev.of_node) {
const struct of_device_id *match;
match = of_match_device(tegra_vi_of_match, &dev->dev);
if (match) {
pdata = (struct nvhost_device_data *)match->data;
dev->dev.platform_data = pdata;
}
/* DT initializes it to -1, use below WAR to set correct value.
* TODO: Once proper fix for dev-id goes in, remove it.
*/
dev->id = dev->dev.id;
} else
pdata = (struct nvhost_device_data *)dev->dev.platform_data;
WARN_ON(!pdata);
if (!pdata) {
dev_info(&dev->dev, "no platform data\n");
return -ENODATA;
}
pdata->pdev = dev;
mutex_init(&pdata->lock);
platform_set_drvdata(dev, pdata);
dev_info(&dev->dev, "%s: ++\n", __func__);
tegra_vi = devm_kzalloc(&dev->dev, sizeof(struct vi), GFP_KERNEL);
if (!tegra_vi) {
dev_err(&dev->dev, "can't allocate memory for vi\n");
return -ENOMEM;
}
err = nvhost_client_device_get_resources(dev);
if (err)
goto vi_probe_fail;
tegra_vi->ndev = dev;
/* call vi_intr_init and stats_work */
INIT_WORK(&tegra_vi->stats_work, vi_stats_worker);
err = vi_intr_init(tegra_vi);
if (err)
goto vi_probe_fail;
vi_create_debugfs(tegra_vi);
i2c_ctrl = pdata->private_data;
pdata->private_data = tegra_vi;
/* Create I2C Devices according to settings from board file */
if (i2c_ctrl && i2c_ctrl->new_devices)
i2c_ctrl->new_devices(dev);
tegra_vi->reg = regulator_get(&tegra_vi->ndev->dev, "avdd_dsi_csi");
if (IS_ERR(tegra_vi->reg)) {
err = PTR_ERR(tegra_vi->reg);
if (err == -ENODEV)
dev_info(&tegra_vi->ndev->dev,
"%s: no regulator device\n", __func__);
else
dev_err(&tegra_vi->ndev->dev,
"%s: couldn't get regulator\n", __func__);
tegra_vi->reg = NULL;
goto camera_i2c_unregister;
}
#ifdef CONFIG_TEGRA_CAMERA
tegra_vi->camera = tegra_camera_register(dev);
if (!tegra_vi->camera) {
dev_err(&dev->dev, "%s: can't register tegra_camera\n",
__func__);
goto vi_regulator_put;
}
#endif
nvhost_module_init(dev);
#ifdef CONFIG_PM_GENERIC_DOMAINS
pdata->pd.name = "ve";
/* add module power domain and also add its domain
* as sub-domain of MC domain */
err = nvhost_module_add_domain(&pdata->pd, dev);
#endif
err = nvhost_client_device_init(dev);
if (err)
goto camera_unregister;
return 0;
camera_unregister:
#ifdef CONFIG_TEGRA_CAMERA
tegra_camera_unregister(tegra_vi->camera);
vi_regulator_put:
#endif
regulator_put(tegra_vi->reg);
tegra_vi->reg = NULL;
camera_i2c_unregister:
if (i2c_ctrl && i2c_ctrl->remove_devices)
i2c_ctrl->remove_devices(dev);
pdata->private_data = i2c_ctrl;
vi_probe_fail:
dev_err(&dev->dev, "%s: failed\n", __func__);
return err;
}
static int __devinit nvhost_probe(struct platform_device *dev)
{
struct nvhost_master *host;
struct resource *regs, *intr0, *intr1;
int i, err;
struct nvhost_device_data *pdata =
(struct nvhost_device_data *)dev->dev.platform_data;
regs = platform_get_resource(dev, IORESOURCE_MEM, 0);
intr0 = platform_get_resource(dev, IORESOURCE_IRQ, 0);
intr1 = platform_get_resource(dev, IORESOURCE_IRQ, 1);
if (!regs || !intr0 || !intr1) {
dev_err(&dev->dev, "missing required platform resources\n");
return -ENXIO;
}
host = kzalloc(sizeof(*host), GFP_KERNEL);
if (!host)
return -ENOMEM;
nvhost = host;
host->dev = dev;
/* Copy host1x parameters. The private_data gets replaced
* by nvhost_master later */
memcpy(&host->info, pdata->private_data,
sizeof(struct host1x_device_info));
pdata->finalize_poweron = power_on_host;
pdata->prepare_poweroff = power_off_host;
pdata->prepare_clockoff = clock_off_host;
pdata->finalize_clockon = clock_on_host;
pdata->pdev = dev;
/* set common host1x device data */
platform_set_drvdata(dev, pdata);
/* set private host1x device data */
nvhost_set_private_data(dev, host);
host->reg_mem = request_mem_region(regs->start,
resource_size(regs), dev->name);
if (!host->reg_mem) {
dev_err(&dev->dev, "failed to get host register memory\n");
err = -ENXIO;
goto fail;
}
host->aperture = ioremap(regs->start, resource_size(regs));
if (!host->aperture) {
dev_err(&dev->dev, "failed to remap host registers\n");
err = -ENXIO;
goto fail;
}
err = nvhost_alloc_resources(host);
if (err) {
dev_err(&dev->dev, "failed to init chip support\n");
goto fail;
}
host->memmgr = mem_op().alloc_mgr();
if (!host->memmgr) {
dev_err(&dev->dev, "unable to create nvmap client\n");
err = -EIO;
goto fail;
}
err = nvhost_syncpt_init(dev, &host->syncpt);
if (err)
goto fail;
err = nvhost_intr_init(&host->intr, intr1->start, intr0->start);
if (err)
goto fail;
err = nvhost_user_init(host);
if (err)
goto fail;
err = nvhost_module_init(dev);
if (err)
goto fail;
for (i = 0; i < pdata->num_clks; i++)
clk_prepare_enable(pdata->clk[i]);
nvhost_syncpt_reset(&host->syncpt);
for (i = 0; i < pdata->num_clks; i++)
clk_disable_unprepare(pdata->clk[i]);
nvhost_device_list_init();
err = nvhost_device_list_add(dev);
if (err)
goto fail;
nvhost_debug_init(host);
dev_info(&dev->dev, "initialized\n");
return 0;
fail:
nvhost_free_resources(host);
if (host->memmgr)
mem_op().put_mgr(host->memmgr);
kfree(host);
return err;
}
static int __devinit nvhost_probe(struct platform_device *pdev)
{
struct nvhost_master *host;
struct resource *regs, *intr0, *intr1;
int i, err;
regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
intr0 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
intr1 = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
if (!regs || !intr0 || !intr1) {
dev_err(&pdev->dev, "missing required platform resources\n");
return -ENXIO;
}
host = kzalloc(sizeof(*host), GFP_KERNEL);
if (!host)
return -ENOMEM;
host->pdev = pdev;
host->nvmap = nvmap_create_client(nvmap_dev, "nvhost");
if (!host->nvmap) {
dev_err(&pdev->dev, "unable to create nvmap client\n");
err = -EIO;
goto fail;
}
host->reg_mem = request_mem_region(regs->start,
resource_size(regs), pdev->name);
if (!host->reg_mem) {
dev_err(&pdev->dev, "failed to get host register memory\n");
err = -ENXIO;
goto fail;
}
host->aperture = ioremap(regs->start, resource_size(regs));
if (!host->aperture) {
dev_err(&pdev->dev, "failed to remap host registers\n");
err = -ENXIO;
goto fail;
}
err = nvhost_init_chip_support(host);
if (err) {
dev_err(&pdev->dev, "failed to init chip support\n");
goto fail;
}
for (i = 0; i < host->nb_channels; i++) {
struct nvhost_channel *ch = &host->channels[i];
BUG_ON(!host_channel_op(host).init);
err = host_channel_op(host).init(ch, host, i);
if (err < 0) {
dev_err(&pdev->dev, "failed to init channel %d\n", i);
goto fail;
}
}
err = nvhost_cpuaccess_init(&host->cpuaccess, pdev);
if (err)
goto fail;
err = nvhost_intr_init(&host->intr, intr1->start, intr0->start);
if (err)
goto fail;
err = nvhost_user_init(host);
if (err)
goto fail;
err = nvhost_module_init(&host->mod, "host1x",
&hostdesc, NULL, &pdev->dev);
for (i = 0; i < host->nb_channels; i++) {
struct nvhost_channel *ch = &host->channels[i];
nvhost_module_preinit(ch->desc->name,
&ch->desc->module);
}
if (err)
goto fail;
platform_set_drvdata(pdev, host);
clk_enable(host->mod.clk[0]);
nvhost_syncpt_reset(&host->syncpt);
clk_disable(host->mod.clk[0]);
nvhost_bus_register(host);
nvhost_debug_init(host);
dev_info(&pdev->dev, "initialized\n");
return 0;
fail:
nvhost_remove_chip_support(host);
if (host->nvmap)
nvmap_client_put(host->nvmap);
kfree(host);
return err;
}
static int vhost_client_probe(struct platform_device *dev)
{
int err;
struct nvhost_device_data *pdata = NULL;
if (dev->dev.of_node) {
const struct of_device_id *match;
match = of_match_device(tegra_client_of_match, &dev->dev);
if (!match)
return -ENODEV;
pdata = (struct nvhost_device_data *)match->data;
#ifdef CONFIG_TEGRA_GRHOST_ISP
/* If ISP, need to differentiate ISP.0 from ISP.1 */
if (!IS_ENABLED(CONFIG_ARCH_TEGRA_18x_SOC)) {
int dev_id = 0;
if (sscanf(dev->name, "%x.isp", &dev_id) == 1) {
switch (tegra_get_chipid()) {
case TEGRA_CHIPID_TEGRA12:
if (dev_id == 0x54600000)
pdata = &t124_isp_info;
if (dev_id == 0x54680000)
pdata = &t124_ispb_info;
break;
default:
/* Only T124 is virtualized, for now */
return -EINVAL;
}
}
}
#endif
}
if (!pdata) {
dev_err(&dev->dev, "no platform data\n");
return -ENODATA;
}
pdata->virtual_dev = true;
nvhost_dbg_fn("dev:%p pdata:%p", dev, pdata);
pdata->pdev = dev;
mutex_init(&pdata->lock);
platform_set_drvdata(dev, pdata);
/* Disable power management when virtual */
pdata->can_powergate = false;
pdata->busy = NULL;
pdata->idle = NULL;
pdata->scaling_init = NULL;
pdata->finalize_poweron = nvhost_vhost_client_finalize_poweron;
pdata->poweron_reset = false;
pdata->engine_cg_regs = NULL;
pdata->keepalive = false;
pdata->hw_init = NULL;
dev->dev.platform_data = NULL;
nvhost_module_init(dev);
#ifdef CONFIG_PM_GENERIC_DOMAINS
pdata->pd.name = kstrdup(dev->name, GFP_KERNEL);
if (!pdata->pd.name)
return -ENOMEM;
err = nvhost_module_add_domain(&pdata->pd, dev);
#endif
err = nvhost_virt_init(dev, pdata->moduleid);
if (err) {
dev_err(&dev->dev, "nvhost_virt_init failed for %s",
dev->name);
pm_runtime_put(&dev->dev);
return err;
}
err = nvhost_client_device_init(dev);
if (err) {
dev_err(&dev->dev, "failed to init client device for %s",
dev->name);
pm_runtime_put(&dev->dev);
return err;
}
return 0;
}
