/* Registration */
struct tegra_overlay_info *tegra_overlay_register(struct nvhost_device *ndev,
struct tegra_dc *dc)
{
struct tegra_overlay_info *dev;
int e;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
dev_err(&ndev->dev, "out of memory for device\n");
return ERR_PTR(-ENOMEM);
}
snprintf(dev->name, sizeof(dev->name), "tegra_dc%u", ndev->id);
dev->ndev = ndev;
dev->dev.minor = MISC_DYNAMIC_MINOR;
dev->dev.name = dev->name;
dev->dev.fops = &overlay_fops;
dev->dev.parent = &ndev->dev;
spin_lock_init(&dev->clients_lock);
INIT_LIST_HEAD(&dev->clients);
mutex_init(&dev->overlays_lock);
e = misc_register(&dev->dev);
if (e) {
dev_err(&ndev->dev, "unable to register miscdevice %s\n",
dev->dev.name);
goto fail;
}
dev->overlay_nvmap = nvmap_create_client(nvmap_dev, "overlay");
if (!dev->overlay_nvmap) {
dev_err(&ndev->dev, "couldn't create nvmap client\n");
e = -ENOMEM;
goto err_free;
}
dev->flip_wq = create_singlethread_workqueue(dev_name(&ndev->dev));
if (!dev->flip_wq) {
dev_err(&ndev->dev, "couldn't create flip work-queue\n");
e = -ENOMEM;
goto err_delete_wq;
}
dev->dc = dc;
dev_info(&ndev->dev, "registered overlay\n");
return dev;
err_delete_wq:
err_free:
fail:
if (dev->dev.minor != MISC_DYNAMIC_MINOR)
misc_deregister(&dev->dev);
kfree(dev);
return ERR_PTR(e);
}
static int tegra_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
int stream , size_t size)
{
struct snd_pcm_substream *substream = pcm->streams[stream].substream;
struct snd_dma_buffer *buf = &substream->dma_buffer;
#if TEGRA30_USE_SMMU
unsigned char *vaddr;
phys_addr_t paddr;
struct tegra_smmu_data *ptsd;
ptsd = kzalloc(sizeof(struct tegra_smmu_data), GFP_KERNEL);
ptsd->pcm_nvmap_client = nvmap_create_client(nvmap_dev, "Audio_SMMU");
ptsd->pcm_nvmap_handle = nvmap_alloc(ptsd->pcm_nvmap_client,
size,
32,
NVMAP_HANDLE_WRITE_COMBINE,
NVMAP_HEAP_IOVMM);
vaddr = (unsigned char *) nvmap_mmap(ptsd->pcm_nvmap_handle);
paddr = nvmap_pin(ptsd->pcm_nvmap_client, ptsd->pcm_nvmap_handle);
buf->area = vaddr;
buf->addr = paddr;
buf->private_data = ptsd;
#else
buf->area = dma_alloc_writecombine(pcm->card->dev, size,
&buf->addr, GFP_KERNEL);
if (!buf->area)
return -ENOMEM;
buf->private_data = NULL;
#endif
buf->dev.type = SNDRV_DMA_TYPE_DEV;
buf->dev.dev = pcm->card->dev;
buf->bytes = size;
return 0;
}
struct tegra_dc_ext *tegra_dc_ext_register(struct nvhost_device *ndev,
struct tegra_dc *dc)
{
int ret;
struct tegra_dc_ext *ext;
int devno;
ext = kzalloc(sizeof(*ext), GFP_KERNEL);
if (!ext)
return ERR_PTR(-ENOMEM);
BUG_ON(!tegra_dc_ext_devno);
devno = tegra_dc_ext_devno + head_count + 1;
cdev_init(&ext->cdev, &tegra_dc_devops);
ext->cdev.owner = THIS_MODULE;
ret = cdev_add(&ext->cdev, devno, 1);
if (ret) {
dev_err(&ndev->dev, "Failed to create character device\n");
goto cleanup_alloc;
}
ext->dev = device_create(tegra_dc_ext_class,
&ndev->dev,
devno,
NULL,
"tegra_dc_%d",
ndev->id);
if (IS_ERR(ext->dev)) {
ret = PTR_ERR(ext->dev);
goto cleanup_cdev;
}
ext->dc = dc;
ext->nvmap = nvmap_create_client(nvmap_dev, "tegra_dc_ext");
if (!ext->nvmap) {
ret = -ENOMEM;
goto cleanup_device;
}
ret = tegra_dc_ext_setup_windows(ext);
if (ret)
goto cleanup_nvmap;
mutex_init(&ext->cursor.lock);
head_count++;
return ext;
cleanup_nvmap:
nvmap_client_put(ext->nvmap);
cleanup_device:
device_del(ext->dev);
cleanup_cdev:
cdev_del(&ext->cdev);
cleanup_alloc:
kfree(ext);
return ERR_PTR(ret);
}
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;
}
struct mem_mgr *nvhost_nvmap_alloc_mgr(void)
{
return (struct mem_mgr *)nvmap_create_client(nvmap_dev, "nvhost");
}
