mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
media: vsp1: Reword uses of 'fragment' as 'body'
Throughout the codebase, the term 'fragment' is used to represent a display list body. This term duplicates the 'body' which is already in use. The datasheet references these objects as a body, therefore replace all mentions of a fragment with a body, along with the corresponding pluralised terms. Signed-off-by: Kieran Bingham <kieran.bingham+renesas@ideasonboard.com> Signed-off-by: Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com> Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
This commit is contained in:
parent
fce34e49e4
commit
764dfee1a1
4 changed files with 70 additions and 72 deletions
|
@ -43,19 +43,19 @@ static int clu_set_table(struct vsp1_clu *clu, struct v4l2_ctrl *ctrl)
|
||||||
struct vsp1_dl_body *dlb;
|
struct vsp1_dl_body *dlb;
|
||||||
unsigned int i;
|
unsigned int i;
|
||||||
|
|
||||||
dlb = vsp1_dl_fragment_alloc(clu->entity.vsp1, 1 + 17 * 17 * 17);
|
dlb = vsp1_dl_body_alloc(clu->entity.vsp1, 1 + 17 * 17 * 17);
|
||||||
if (!dlb)
|
if (!dlb)
|
||||||
return -ENOMEM;
|
return -ENOMEM;
|
||||||
|
|
||||||
vsp1_dl_fragment_write(dlb, VI6_CLU_ADDR, 0);
|
vsp1_dl_body_write(dlb, VI6_CLU_ADDR, 0);
|
||||||
for (i = 0; i < 17 * 17 * 17; ++i)
|
for (i = 0; i < 17 * 17 * 17; ++i)
|
||||||
vsp1_dl_fragment_write(dlb, VI6_CLU_DATA, ctrl->p_new.p_u32[i]);
|
vsp1_dl_body_write(dlb, VI6_CLU_DATA, ctrl->p_new.p_u32[i]);
|
||||||
|
|
||||||
spin_lock_irq(&clu->lock);
|
spin_lock_irq(&clu->lock);
|
||||||
swap(clu->clu, dlb);
|
swap(clu->clu, dlb);
|
||||||
spin_unlock_irq(&clu->lock);
|
spin_unlock_irq(&clu->lock);
|
||||||
|
|
||||||
vsp1_dl_fragment_free(dlb);
|
vsp1_dl_body_free(dlb);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -211,7 +211,7 @@ static void clu_configure(struct vsp1_entity *entity,
|
||||||
spin_unlock_irqrestore(&clu->lock, flags);
|
spin_unlock_irqrestore(&clu->lock, flags);
|
||||||
|
|
||||||
if (dlb)
|
if (dlb)
|
||||||
vsp1_dl_list_add_fragment(dl, dlb);
|
vsp1_dl_list_add_body(dl, dlb);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -65,7 +65,7 @@ struct vsp1_dl_body {
|
||||||
* @header: display list header, NULL for headerless lists
|
* @header: display list header, NULL for headerless lists
|
||||||
* @dma: DMA address for the header
|
* @dma: DMA address for the header
|
||||||
* @body0: first display list body
|
* @body0: first display list body
|
||||||
* @fragments: list of extra display list bodies
|
* @bodies: list of extra display list bodies
|
||||||
* @has_chain: if true, indicates that there's a partition chain
|
* @has_chain: if true, indicates that there's a partition chain
|
||||||
* @chain: entry in the display list partition chain
|
* @chain: entry in the display list partition chain
|
||||||
* @internal: whether the display list is used for internal purpose
|
* @internal: whether the display list is used for internal purpose
|
||||||
|
@ -78,7 +78,7 @@ struct vsp1_dl_list {
|
||||||
dma_addr_t dma;
|
dma_addr_t dma;
|
||||||
|
|
||||||
struct vsp1_dl_body body0;
|
struct vsp1_dl_body body0;
|
||||||
struct list_head fragments;
|
struct list_head bodies;
|
||||||
|
|
||||||
bool has_chain;
|
bool has_chain;
|
||||||
struct list_head chain;
|
struct list_head chain;
|
||||||
|
@ -97,13 +97,13 @@ enum vsp1_dl_mode {
|
||||||
* @mode: display list operation mode (header or headerless)
|
* @mode: display list operation mode (header or headerless)
|
||||||
* @singleshot: execute the display list in single-shot mode
|
* @singleshot: execute the display list in single-shot mode
|
||||||
* @vsp1: the VSP1 device
|
* @vsp1: the VSP1 device
|
||||||
* @lock: protects the free, active, queued, pending and gc_fragments lists
|
* @lock: protects the free, active, queued, pending and gc_bodies lists
|
||||||
* @free: array of all free display lists
|
* @free: array of all free display lists
|
||||||
* @active: list currently being processed (loaded) by hardware
|
* @active: list currently being processed (loaded) by hardware
|
||||||
* @queued: list queued to the hardware (written to the DL registers)
|
* @queued: list queued to the hardware (written to the DL registers)
|
||||||
* @pending: list waiting to be queued to the hardware
|
* @pending: list waiting to be queued to the hardware
|
||||||
* @gc_work: fragments garbage collector work struct
|
* @gc_work: bodies garbage collector work struct
|
||||||
* @gc_fragments: array of display list fragments waiting to be freed
|
* @gc_bodies: array of display list bodies waiting to be freed
|
||||||
*/
|
*/
|
||||||
struct vsp1_dl_manager {
|
struct vsp1_dl_manager {
|
||||||
unsigned int index;
|
unsigned int index;
|
||||||
|
@ -118,7 +118,7 @@ struct vsp1_dl_manager {
|
||||||
struct vsp1_dl_list *pending;
|
struct vsp1_dl_list *pending;
|
||||||
|
|
||||||
struct work_struct gc_work;
|
struct work_struct gc_work;
|
||||||
struct list_head gc_fragments;
|
struct list_head gc_bodies;
|
||||||
};
|
};
|
||||||
|
|
||||||
/* -----------------------------------------------------------------------------
|
/* -----------------------------------------------------------------------------
|
||||||
|
@ -156,17 +156,16 @@ static void vsp1_dl_body_cleanup(struct vsp1_dl_body *dlb)
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* vsp1_dl_fragment_alloc - Allocate a display list fragment
|
* vsp1_dl_body_alloc - Allocate a display list body
|
||||||
* @vsp1: The VSP1 device
|
* @vsp1: The VSP1 device
|
||||||
* @num_entries: The maximum number of entries that the fragment can contain
|
* @num_entries: The maximum number of entries that the body can contain
|
||||||
*
|
*
|
||||||
* Allocate a display list fragment with enough memory to contain the requested
|
* Allocate a display list body with enough memory to contain the requested
|
||||||
* number of entries.
|
* number of entries.
|
||||||
*
|
*
|
||||||
* Return a pointer to a fragment on success or NULL if memory can't be
|
* Return a pointer to a body on success or NULL if memory can't be allocated.
|
||||||
* allocated.
|
|
||||||
*/
|
*/
|
||||||
struct vsp1_dl_body *vsp1_dl_fragment_alloc(struct vsp1_device *vsp1,
|
struct vsp1_dl_body *vsp1_dl_body_alloc(struct vsp1_device *vsp1,
|
||||||
unsigned int num_entries)
|
unsigned int num_entries)
|
||||||
{
|
{
|
||||||
struct vsp1_dl_body *dlb;
|
struct vsp1_dl_body *dlb;
|
||||||
|
@ -186,20 +185,20 @@ struct vsp1_dl_body *vsp1_dl_fragment_alloc(struct vsp1_device *vsp1,
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* vsp1_dl_fragment_free - Free a display list fragment
|
* vsp1_dl_body_free - Free a display list body
|
||||||
* @dlb: The fragment
|
* @dlb: The body
|
||||||
*
|
*
|
||||||
* Free the given display list fragment and the associated DMA memory.
|
* Free the given display list body and the associated DMA memory.
|
||||||
*
|
*
|
||||||
* Fragments must only be freed explicitly if they are not added to a display
|
* Bodies must only be freed explicitly if they are not added to a display
|
||||||
* list, as the display list will take ownership of them and free them
|
* list, as the display list will take ownership of them and free them
|
||||||
* otherwise. Manual free typically happens at cleanup time for fragments that
|
* otherwise. Manual free typically happens at cleanup time for bodies that
|
||||||
* have been allocated but not used.
|
* have been allocated but not used.
|
||||||
*
|
*
|
||||||
* Passing a NULL pointer to this function is safe, in that case no operation
|
* Passing a NULL pointer to this function is safe, in that case no operation
|
||||||
* will be performed.
|
* will be performed.
|
||||||
*/
|
*/
|
||||||
void vsp1_dl_fragment_free(struct vsp1_dl_body *dlb)
|
void vsp1_dl_body_free(struct vsp1_dl_body *dlb)
|
||||||
{
|
{
|
||||||
if (!dlb)
|
if (!dlb)
|
||||||
return;
|
return;
|
||||||
|
@ -209,16 +208,16 @@ void vsp1_dl_fragment_free(struct vsp1_dl_body *dlb)
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* vsp1_dl_fragment_write - Write a register to a display list fragment
|
* vsp1_dl_body_write - Write a register to a display list body
|
||||||
* @dlb: The fragment
|
* @dlb: The body
|
||||||
* @reg: The register address
|
* @reg: The register address
|
||||||
* @data: The register value
|
* @data: The register value
|
||||||
*
|
*
|
||||||
* Write the given register and value to the display list fragment. The maximum
|
* Write the given register and value to the display list body. The maximum
|
||||||
* number of entries that can be written in a fragment is specified when the
|
* number of entries that can be written in a body is specified when the body is
|
||||||
* fragment is allocated by vsp1_dl_fragment_alloc().
|
* allocated by vsp1_dl_body_alloc().
|
||||||
*/
|
*/
|
||||||
void vsp1_dl_fragment_write(struct vsp1_dl_body *dlb, u32 reg, u32 data)
|
void vsp1_dl_body_write(struct vsp1_dl_body *dlb, u32 reg, u32 data)
|
||||||
{
|
{
|
||||||
dlb->entries[dlb->num_entries].addr = reg;
|
dlb->entries[dlb->num_entries].addr = reg;
|
||||||
dlb->entries[dlb->num_entries].data = data;
|
dlb->entries[dlb->num_entries].data = data;
|
||||||
|
@ -239,7 +238,7 @@ static struct vsp1_dl_list *vsp1_dl_list_alloc(struct vsp1_dl_manager *dlm)
|
||||||
if (!dl)
|
if (!dl)
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
||||||
INIT_LIST_HEAD(&dl->fragments);
|
INIT_LIST_HEAD(&dl->bodies);
|
||||||
dl->dlm = dlm;
|
dl->dlm = dlm;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -276,7 +275,7 @@ static struct vsp1_dl_list *vsp1_dl_list_alloc(struct vsp1_dl_manager *dlm)
|
||||||
static void vsp1_dl_list_free(struct vsp1_dl_list *dl)
|
static void vsp1_dl_list_free(struct vsp1_dl_list *dl)
|
||||||
{
|
{
|
||||||
vsp1_dl_body_cleanup(&dl->body0);
|
vsp1_dl_body_cleanup(&dl->body0);
|
||||||
list_splice_init(&dl->fragments, &dl->dlm->gc_fragments);
|
list_splice_init(&dl->bodies, &dl->dlm->gc_bodies);
|
||||||
kfree(dl);
|
kfree(dl);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -331,13 +330,13 @@ static void __vsp1_dl_list_put(struct vsp1_dl_list *dl)
|
||||||
dl->has_chain = false;
|
dl->has_chain = false;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* We can't free fragments here as DMA memory can only be freed in
|
* We can't free bodies here as DMA memory can only be freed in
|
||||||
* interruptible context. Move all fragments to the display list
|
* interruptible context. Move all bodies to the display list manager's
|
||||||
* manager's list of fragments to be freed, they will be
|
* list of bodies to be freed, they will be garbage-collected by the
|
||||||
* garbage-collected by the work queue.
|
* work queue.
|
||||||
*/
|
*/
|
||||||
if (!list_empty(&dl->fragments)) {
|
if (!list_empty(&dl->bodies)) {
|
||||||
list_splice_init(&dl->fragments, &dl->dlm->gc_fragments);
|
list_splice_init(&dl->bodies, &dl->dlm->gc_bodies);
|
||||||
schedule_work(&dl->dlm->gc_work);
|
schedule_work(&dl->dlm->gc_work);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -378,33 +377,33 @@ void vsp1_dl_list_put(struct vsp1_dl_list *dl)
|
||||||
*/
|
*/
|
||||||
void vsp1_dl_list_write(struct vsp1_dl_list *dl, u32 reg, u32 data)
|
void vsp1_dl_list_write(struct vsp1_dl_list *dl, u32 reg, u32 data)
|
||||||
{
|
{
|
||||||
vsp1_dl_fragment_write(&dl->body0, reg, data);
|
vsp1_dl_body_write(&dl->body0, reg, data);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* vsp1_dl_list_add_fragment - Add a fragment to the display list
|
* vsp1_dl_list_add_body - Add a body to the display list
|
||||||
* @dl: The display list
|
* @dl: The display list
|
||||||
* @dlb: The fragment
|
* @dlb: The body
|
||||||
*
|
*
|
||||||
* Add a display list body as a fragment to a display list. Registers contained
|
* Add a display list body to a display list. Registers contained in bodies are
|
||||||
* in fragments are processed after registers contained in the main display
|
* processed after registers contained in the main display list, in the order in
|
||||||
* list, in the order in which fragments are added.
|
* which bodies are added.
|
||||||
*
|
*
|
||||||
* Adding a fragment to a display list passes ownership of the fragment to the
|
* Adding a body to a display list passes ownership of the body to the list. The
|
||||||
* list. The caller must not touch the fragment after this call, and must not
|
* caller must not touch the body after this call, and must not free it
|
||||||
* free it explicitly with vsp1_dl_fragment_free().
|
* explicitly with vsp1_dl_body_free().
|
||||||
*
|
*
|
||||||
* Fragments are only usable for display lists in header mode. Attempt to
|
* Additional bodies are only usable for display lists in header mode.
|
||||||
* add a fragment to a header-less display list will return an error.
|
* Attempting to add a body to a header-less display list will return an error.
|
||||||
*/
|
*/
|
||||||
int vsp1_dl_list_add_fragment(struct vsp1_dl_list *dl,
|
int vsp1_dl_list_add_body(struct vsp1_dl_list *dl, struct vsp1_dl_body *dlb)
|
||||||
struct vsp1_dl_body *dlb)
|
|
||||||
{
|
{
|
||||||
/* Multi-body lists are only available in header mode. */
|
/* Multi-body lists are only available in header mode. */
|
||||||
if (dl->dlm->mode != VSP1_DL_MODE_HEADER)
|
if (dl->dlm->mode != VSP1_DL_MODE_HEADER)
|
||||||
return -EINVAL;
|
return -EINVAL;
|
||||||
|
|
||||||
list_add_tail(&dlb->list, &dl->fragments);
|
list_add_tail(&dlb->list, &dl->bodies);
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -453,7 +452,7 @@ static void vsp1_dl_list_fill_header(struct vsp1_dl_list *dl, bool is_last)
|
||||||
hdr->num_bytes = dl->body0.num_entries
|
hdr->num_bytes = dl->body0.num_entries
|
||||||
* sizeof(*dl->header->lists);
|
* sizeof(*dl->header->lists);
|
||||||
|
|
||||||
list_for_each_entry(dlb, &dl->fragments, list) {
|
list_for_each_entry(dlb, &dl->bodies, list) {
|
||||||
num_lists++;
|
num_lists++;
|
||||||
hdr++;
|
hdr++;
|
||||||
|
|
||||||
|
@ -732,25 +731,25 @@ void vsp1_dlm_reset(struct vsp1_dl_manager *dlm)
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Free all fragments awaiting to be garbage-collected.
|
* Free all bodies awaiting to be garbage-collected.
|
||||||
*
|
*
|
||||||
* This function must be called without the display list manager lock held.
|
* This function must be called without the display list manager lock held.
|
||||||
*/
|
*/
|
||||||
static void vsp1_dlm_fragments_free(struct vsp1_dl_manager *dlm)
|
static void vsp1_dlm_bodies_free(struct vsp1_dl_manager *dlm)
|
||||||
{
|
{
|
||||||
unsigned long flags;
|
unsigned long flags;
|
||||||
|
|
||||||
spin_lock_irqsave(&dlm->lock, flags);
|
spin_lock_irqsave(&dlm->lock, flags);
|
||||||
|
|
||||||
while (!list_empty(&dlm->gc_fragments)) {
|
while (!list_empty(&dlm->gc_bodies)) {
|
||||||
struct vsp1_dl_body *dlb;
|
struct vsp1_dl_body *dlb;
|
||||||
|
|
||||||
dlb = list_first_entry(&dlm->gc_fragments, struct vsp1_dl_body,
|
dlb = list_first_entry(&dlm->gc_bodies, struct vsp1_dl_body,
|
||||||
list);
|
list);
|
||||||
list_del(&dlb->list);
|
list_del(&dlb->list);
|
||||||
|
|
||||||
spin_unlock_irqrestore(&dlm->lock, flags);
|
spin_unlock_irqrestore(&dlm->lock, flags);
|
||||||
vsp1_dl_fragment_free(dlb);
|
vsp1_dl_body_free(dlb);
|
||||||
spin_lock_irqsave(&dlm->lock, flags);
|
spin_lock_irqsave(&dlm->lock, flags);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -762,7 +761,7 @@ static void vsp1_dlm_garbage_collect(struct work_struct *work)
|
||||||
struct vsp1_dl_manager *dlm =
|
struct vsp1_dl_manager *dlm =
|
||||||
container_of(work, struct vsp1_dl_manager, gc_work);
|
container_of(work, struct vsp1_dl_manager, gc_work);
|
||||||
|
|
||||||
vsp1_dlm_fragments_free(dlm);
|
vsp1_dlm_bodies_free(dlm);
|
||||||
}
|
}
|
||||||
|
|
||||||
struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device *vsp1,
|
struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device *vsp1,
|
||||||
|
@ -784,7 +783,7 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device *vsp1,
|
||||||
|
|
||||||
spin_lock_init(&dlm->lock);
|
spin_lock_init(&dlm->lock);
|
||||||
INIT_LIST_HEAD(&dlm->free);
|
INIT_LIST_HEAD(&dlm->free);
|
||||||
INIT_LIST_HEAD(&dlm->gc_fragments);
|
INIT_LIST_HEAD(&dlm->gc_bodies);
|
||||||
INIT_WORK(&dlm->gc_work, vsp1_dlm_garbage_collect);
|
INIT_WORK(&dlm->gc_work, vsp1_dlm_garbage_collect);
|
||||||
|
|
||||||
for (i = 0; i < prealloc; ++i) {
|
for (i = 0; i < prealloc; ++i) {
|
||||||
|
@ -814,5 +813,5 @@ void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm)
|
||||||
vsp1_dl_list_free(dl);
|
vsp1_dl_list_free(dl);
|
||||||
}
|
}
|
||||||
|
|
||||||
vsp1_dlm_fragments_free(dlm);
|
vsp1_dlm_bodies_free(dlm);
|
||||||
}
|
}
|
||||||
|
|
|
@ -12,7 +12,7 @@
|
||||||
#include <linux/types.h>
|
#include <linux/types.h>
|
||||||
|
|
||||||
struct vsp1_device;
|
struct vsp1_device;
|
||||||
struct vsp1_dl_fragment;
|
struct vsp1_dl_body;
|
||||||
struct vsp1_dl_list;
|
struct vsp1_dl_list;
|
||||||
struct vsp1_dl_manager;
|
struct vsp1_dl_manager;
|
||||||
|
|
||||||
|
@ -33,12 +33,11 @@ void vsp1_dl_list_put(struct vsp1_dl_list *dl);
|
||||||
void vsp1_dl_list_write(struct vsp1_dl_list *dl, u32 reg, u32 data);
|
void vsp1_dl_list_write(struct vsp1_dl_list *dl, u32 reg, u32 data);
|
||||||
void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool internal);
|
void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool internal);
|
||||||
|
|
||||||
struct vsp1_dl_body *vsp1_dl_fragment_alloc(struct vsp1_device *vsp1,
|
struct vsp1_dl_body *vsp1_dl_body_alloc(struct vsp1_device *vsp1,
|
||||||
unsigned int num_entries);
|
unsigned int num_entries);
|
||||||
void vsp1_dl_fragment_free(struct vsp1_dl_body *dlb);
|
void vsp1_dl_body_free(struct vsp1_dl_body *dlb);
|
||||||
void vsp1_dl_fragment_write(struct vsp1_dl_body *dlb, u32 reg, u32 data);
|
void vsp1_dl_body_write(struct vsp1_dl_body *dlb, u32 reg, u32 data);
|
||||||
int vsp1_dl_list_add_fragment(struct vsp1_dl_list *dl,
|
int vsp1_dl_list_add_body(struct vsp1_dl_list *dl, struct vsp1_dl_body *dlb);
|
||||||
struct vsp1_dl_body *dlb);
|
|
||||||
int vsp1_dl_list_add_chain(struct vsp1_dl_list *head, struct vsp1_dl_list *dl);
|
int vsp1_dl_list_add_chain(struct vsp1_dl_list *head, struct vsp1_dl_list *dl);
|
||||||
|
|
||||||
#endif /* __VSP1_DL_H__ */
|
#endif /* __VSP1_DL_H__ */
|
||||||
|
|
|
@ -40,19 +40,19 @@ static int lut_set_table(struct vsp1_lut *lut, struct v4l2_ctrl *ctrl)
|
||||||
struct vsp1_dl_body *dlb;
|
struct vsp1_dl_body *dlb;
|
||||||
unsigned int i;
|
unsigned int i;
|
||||||
|
|
||||||
dlb = vsp1_dl_fragment_alloc(lut->entity.vsp1, 256);
|
dlb = vsp1_dl_body_alloc(lut->entity.vsp1, 256);
|
||||||
if (!dlb)
|
if (!dlb)
|
||||||
return -ENOMEM;
|
return -ENOMEM;
|
||||||
|
|
||||||
for (i = 0; i < 256; ++i)
|
for (i = 0; i < 256; ++i)
|
||||||
vsp1_dl_fragment_write(dlb, VI6_LUT_TABLE + 4 * i,
|
vsp1_dl_body_write(dlb, VI6_LUT_TABLE + 4 * i,
|
||||||
ctrl->p_new.p_u32[i]);
|
ctrl->p_new.p_u32[i]);
|
||||||
|
|
||||||
spin_lock_irq(&lut->lock);
|
spin_lock_irq(&lut->lock);
|
||||||
swap(lut->lut, dlb);
|
swap(lut->lut, dlb);
|
||||||
spin_unlock_irq(&lut->lock);
|
spin_unlock_irq(&lut->lock);
|
||||||
|
|
||||||
vsp1_dl_fragment_free(dlb);
|
vsp1_dl_body_free(dlb);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -167,7 +167,7 @@ static void lut_configure(struct vsp1_entity *entity,
|
||||||
spin_unlock_irqrestore(&lut->lock, flags);
|
spin_unlock_irqrestore(&lut->lock, flags);
|
||||||
|
|
||||||
if (dlb)
|
if (dlb)
|
||||||
vsp1_dl_list_add_fragment(dl, dlb);
|
vsp1_dl_list_add_body(dl, dlb);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in a new issue