mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

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:
Kieran Bingham 2018-05-18 16:41:56 -04:00 committed by Mauro Carvalho Chehab
parent fce34e49e4
commit 764dfee1a1
4 changed files with 70 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
drivers/media/platform/vsp1/vsp1_clu.c
View File

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

111
drivers/media/platform/vsp1/vsp1_dl.c
View File

@ -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,18 +156,17 @@ 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;
int ret; int ret;
@ -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);
} }

13
drivers/media/platform/vsp1/vsp1_dl.h
View File

@ -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__ */

8
drivers/media/platform/vsp1/vsp1_lut.c
View File

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