static int allocate_sram(struct snd_pcm_substream *substream, struct gen_pool *sram_pool, unsigned size, struct snd_pcm_hardware *ppcm) { struct snd_dma_buffer *buf = &substream->dma_buffer; struct snd_dma_buffer *iram_dma = NULL; dma_addr_t iram_phys = 0; void *iram_virt = NULL; if (buf->private_data || !size) return 0; ppcm->period_bytes_max = size; iram_virt = gen_pool_dma_alloc(sram_pool, size, &iram_phys); if (!iram_virt) goto exit1; iram_dma = kzalloc(sizeof(*iram_dma), GFP_KERNEL); if (!iram_dma) goto exit2; iram_dma->area = iram_virt; iram_dma->addr = iram_phys; memset(iram_dma->area, 0, size); iram_dma->bytes = size; buf->private_data = iram_dma; return 0; exit2: if (iram_virt) gen_pool_free(sram_pool, (unsigned)iram_virt, size); exit1: return -ENOMEM; }
void *hgsmi_buffer_alloc(struct gen_pool *guest_pool, size_t size, u8 channel, u16 channel_info) { HGSMIBUFFERHEADER *h; HGSMIBUFFERTAIL *t; size_t total_size; dma_addr_t offset; total_size = size + sizeof(*h) + sizeof(*t); h = gen_pool_dma_alloc(guest_pool, total_size, &offset); if (!h) return NULL; t = (HGSMIBUFFERTAIL *)((u8 *)h + sizeof(*h) + size); h->u8Flags = HGSMI_BUFFER_HEADER_F_SEQ_SINGLE; h->u32DataSize = size; h->u8Channel = channel; h->u16ChannelInfo = channel_info; memset(&h->u.au8Union, 0, sizeof(h->u.au8Union)); t->u32Reserved = 0; t->u32Checksum = hgsmi_checksum(offset, h, t); return (u8 *)h + sizeof(*h); }
void *sram_alloc(size_t len, dma_addr_t *dma) { dma_addr_t dma_base = davinci_soc_info.sram_dma; if (dma) *dma = 0; if (!sram_pool || (dma && !dma_base)) return NULL; return gen_pool_dma_alloc(sram_pool, len, dma); }
static struct mmp_tdma_desc *mmp_tdma_alloc_descriptor(struct mmp_tdma_chan *tdmac) { struct gen_pool *gpool; int size = tdmac->desc_num * sizeof(struct mmp_tdma_desc); gpool = tdmac->pool; if (!gpool) return NULL; tdmac->desc_arr = gen_pool_dma_alloc(gpool, size, &tdmac->desc_arr_phys); return tdmac->desc_arr; }
static int mvneta_bm_get_sram(struct device_node *dn, struct mvneta_bm *priv) { priv->bppi_pool = of_gen_pool_get(dn, "internal-mem", 0); if (!priv->bppi_pool) return -ENOMEM; priv->bppi_virt_addr = gen_pool_dma_alloc(priv->bppi_pool, MVNETA_BM_BPPI_SIZE, &priv->bppi_phys_addr); if (!priv->bppi_virt_addr) return -ENOMEM; return 0; }
/** * snd_malloc_dev_iram - allocate memory from on-chip internal ram * @dmab: buffer allocation record to store the allocated data * @size: number of bytes to allocate from the iram * * This function requires iram phandle provided via of_node */ static void snd_malloc_dev_iram(struct snd_dma_buffer *dmab, size_t size) { struct device *dev = dmab->dev.dev; struct gen_pool *pool = NULL; dmab->area = NULL; dmab->addr = 0; if (dev->of_node) pool = of_gen_pool_get(dev->of_node, "iram", 0); if (!pool) return; /* Assign the pool into private_data field */ dmab->private_data = pool; dmab->area = gen_pool_dma_alloc(pool, size, &dmab->addr); }
static int pruss_probe(struct platform_device *dev) { struct uio_info *p; struct uio_pruss_dev *gdev; struct resource *regs_prussio; int ret = -ENODEV, cnt = 0, len; struct uio_pruss_pdata *pdata = dev_get_platdata(&dev->dev); gdev = kzalloc(sizeof(struct uio_pruss_dev), GFP_KERNEL); if (!gdev) return -ENOMEM; gdev->info = kzalloc(sizeof(*p) * MAX_PRUSS_EVT, GFP_KERNEL); if (!gdev->info) { kfree(gdev); return -ENOMEM; } /* Power on PRU in case its not done as part of boot-loader */ gdev->pruss_clk = clk_get(&dev->dev, "pruss"); if (IS_ERR(gdev->pruss_clk)) { dev_err(&dev->dev, "Failed to get clock\n"); ret = PTR_ERR(gdev->pruss_clk); kfree(gdev->info); kfree(gdev); return ret; } else { clk_enable(gdev->pruss_clk); } regs_prussio = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!regs_prussio) { dev_err(&dev->dev, "No PRUSS I/O resource specified\n"); goto out_free; } if (!regs_prussio->start) { dev_err(&dev->dev, "Invalid memory resource\n"); goto out_free; } if (pdata->sram_pool) { gdev->sram_pool = pdata->sram_pool; gdev->sram_vaddr = (unsigned long)gen_pool_dma_alloc(gdev->sram_pool, sram_pool_sz, &gdev->sram_paddr); if (!gdev->sram_vaddr) { dev_err(&dev->dev, "Could not allocate SRAM pool\n"); goto out_free; } } gdev->ddr_vaddr = dma_alloc_coherent(&dev->dev, extram_pool_sz, &(gdev->ddr_paddr), GFP_KERNEL | GFP_DMA); if (!gdev->ddr_vaddr) { dev_err(&dev->dev, "Could not allocate external memory\n"); goto out_free; } len = resource_size(regs_prussio); gdev->prussio_vaddr = ioremap(regs_prussio->start, len); if (!gdev->prussio_vaddr) { dev_err(&dev->dev, "Can't remap PRUSS I/O address range\n"); goto out_free; } gdev->pintc_base = pdata->pintc_base; gdev->hostirq_start = platform_get_irq(dev, 0); for (cnt = 0, p = gdev->info; cnt < MAX_PRUSS_EVT; cnt++, p++) { p->mem[0].addr = regs_prussio->start; p->mem[0].size = resource_size(regs_prussio); p->mem[0].memtype = UIO_MEM_PHYS; p->mem[1].addr = gdev->sram_paddr; p->mem[1].size = sram_pool_sz; p->mem[1].memtype = UIO_MEM_PHYS; p->mem[2].addr = gdev->ddr_paddr; p->mem[2].size = extram_pool_sz; p->mem[2].memtype = UIO_MEM_PHYS; p->name = kasprintf(GFP_KERNEL, "pruss_evt%d", cnt); p->version = DRV_VERSION; /* Register PRUSS IRQ lines */ p->irq = gdev->hostirq_start + cnt; p->handler = pruss_handler; p->priv = gdev; ret = uio_register_device(&dev->dev, p); if (ret < 0) goto out_free; } platform_set_drvdata(dev, gdev); return 0; out_free: pruss_cleanup(dev, gdev); return ret; }