| // SPDX-License-Identifier: GPL-2.0+ |
| /* |
| * vsp1_dl.c -- R-Car VSP1 Display List |
| * |
| * Copyright (C) 2015 Renesas Corporation |
| * |
| * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com) |
| */ |
| |
| #include <linux/device.h> |
| #include <linux/dma-mapping.h> |
| #include <linux/gfp.h> |
| #include <linux/refcount.h> |
| #include <linux/slab.h> |
| #include <linux/workqueue.h> |
| |
| #include "vsp1.h" |
| #include "vsp1_dl.h" |
| |
| #define VSP1_DL_NUM_ENTRIES 256 |
| |
| #define VSP1_DLH_INT_ENABLE (1 << 1) |
| #define VSP1_DLH_AUTO_START (1 << 0) |
| |
| #define VSP1_DLH_EXT_PRE_CMD_EXEC (1 << 9) |
| #define VSP1_DLH_EXT_POST_CMD_EXEC (1 << 8) |
| |
| struct vsp1_dl_header_list { |
| u32 num_bytes; |
| u32 addr; |
| } __packed; |
| |
| struct vsp1_dl_header { |
| u32 num_lists; |
| struct vsp1_dl_header_list lists[8]; |
| u32 next_header; |
| u32 flags; |
| } __packed; |
| |
| /** |
| * struct vsp1_dl_ext_header - Extended display list header |
| * @padding: padding zero bytes for alignment |
| * @pre_ext_dl_num_cmd: number of pre-extended command bodies to parse |
| * @flags: enables or disables execution of the pre and post command |
| * @pre_ext_dl_plist: start address of pre-extended display list bodies |
| * @post_ext_dl_num_cmd: number of post-extended command bodies to parse |
| * @post_ext_dl_plist: start address of post-extended display list bodies |
| */ |
| struct vsp1_dl_ext_header { |
| u32 padding; |
| |
| /* |
| * The datasheet represents flags as stored before pre_ext_dl_num_cmd, |
| * expecting 32-bit accesses. The flags are appropriate to the whole |
| * header, not just the pre_ext command, and thus warrant being |
| * separated out. Due to byte ordering, and representing as 16 bit |
| * values here, the flags must be positioned after the |
| * pre_ext_dl_num_cmd. |
| */ |
| u16 pre_ext_dl_num_cmd; |
| u16 flags; |
| u32 pre_ext_dl_plist; |
| |
| u32 post_ext_dl_num_cmd; |
| u32 post_ext_dl_plist; |
| } __packed; |
| |
| struct vsp1_dl_header_extended { |
| struct vsp1_dl_header header; |
| struct vsp1_dl_ext_header ext; |
| } __packed; |
| |
| struct vsp1_dl_entry { |
| u32 addr; |
| u32 data; |
| } __packed; |
| |
| /** |
| * struct vsp1_pre_ext_dl_body - Pre Extended Display List Body |
| * @opcode: Extended display list command operation code |
| * @flags: Pre-extended command flags. These are specific to each command |
| * @address_set: Source address set pointer. Must have 16-byte alignment |
| * @reserved: Zero bits for alignment. |
| */ |
| struct vsp1_pre_ext_dl_body { |
| u32 opcode; |
| u32 flags; |
| u32 address_set; |
| u32 reserved; |
| } __packed; |
| |
| /** |
| * struct vsp1_dl_body - Display list body |
| * @list: entry in the display list list of bodies |
| * @free: entry in the pool free body list |
| * @refcnt: reference tracking for the body |
| * @pool: pool to which this body belongs |
| * @entries: array of entries |
| * @dma: DMA address of the entries |
| * @size: size of the DMA memory in bytes |
| * @num_entries: number of stored entries |
| * @max_entries: number of entries available |
| */ |
| struct vsp1_dl_body { |
| struct list_head list; |
| struct list_head free; |
| |
| refcount_t refcnt; |
| |
| struct vsp1_dl_body_pool *pool; |
| |
| struct vsp1_dl_entry *entries; |
| dma_addr_t dma; |
| size_t size; |
| |
| unsigned int num_entries; |
| unsigned int max_entries; |
| }; |
| |
| /** |
| * struct vsp1_dl_body_pool - display list body pool |
| * @dma: DMA address of the entries |
| * @size: size of the full DMA memory pool in bytes |
| * @mem: CPU memory pointer for the pool |
| * @bodies: Array of DLB structures for the pool |
| * @free: List of free DLB entries |
| * @lock: Protects the free list |
| * @vsp1: the VSP1 device |
| */ |
| struct vsp1_dl_body_pool { |
| /* DMA allocation */ |
| dma_addr_t dma; |
| size_t size; |
| void *mem; |
| |
| /* Body management */ |
| struct vsp1_dl_body *bodies; |
| struct list_head free; |
| spinlock_t lock; |
| |
| struct vsp1_device *vsp1; |
| }; |
| |
| /** |
| * struct vsp1_cmd_pool - Display List commands pool |
| * @dma: DMA address of the entries |
| * @size: size of the full DMA memory pool in bytes |
| * @mem: CPU memory pointer for the pool |
| * @cmds: Array of command structures for the pool |
| * @free: Free pool entries |
| * @lock: Protects the free list |
| * @vsp1: the VSP1 device |
| */ |
| struct vsp1_dl_cmd_pool { |
| /* DMA allocation */ |
| dma_addr_t dma; |
| size_t size; |
| void *mem; |
| |
| struct vsp1_dl_ext_cmd *cmds; |
| struct list_head free; |
| |
| spinlock_t lock; |
| |
| struct vsp1_device *vsp1; |
| }; |
| |
| /** |
| * struct vsp1_dl_list - Display list |
| * @list: entry in the display list manager lists |
| * @dlm: the display list manager |
| * @header: display list header |
| * @extension: extended display list header. NULL for normal lists |
| * @dma: DMA address for the header |
| * @body0: first display list body |
| * @bodies: list of extra display list bodies |
| * @pre_cmd: pre command to be issued through extended dl header |
| * @post_cmd: post command to be issued through extended dl header |
| * @has_chain: if true, indicates that there's a partition chain |
| * @chain: entry in the display list partition chain |
| * @flags: display list flags, a combination of VSP1_DL_FRAME_END_* |
| */ |
| struct vsp1_dl_list { |
| struct list_head list; |
| struct vsp1_dl_manager *dlm; |
| |
| struct vsp1_dl_header *header; |
| struct vsp1_dl_ext_header *extension; |
| dma_addr_t dma; |
| |
| struct vsp1_dl_body *body0; |
| struct list_head bodies; |
| |
| struct vsp1_dl_ext_cmd *pre_cmd; |
| struct vsp1_dl_ext_cmd *post_cmd; |
| |
| bool has_chain; |
| struct list_head chain; |
| |
| unsigned int flags; |
| }; |
| |
| /** |
| * struct vsp1_dl_manager - Display List manager |
| * @index: index of the related WPF |
| * @singleshot: execute the display list in single-shot mode |
| * @vsp1: the VSP1 device |
| * @lock: protects the free, active, queued, and pending lists |
| * @free: array of all free display lists |
| * @active: list currently being processed (loaded) by hardware |
| * @queued: list queued to the hardware (written to the DL registers) |
| * @pending: list waiting to be queued to the hardware |
| * @pool: body pool for the display list bodies |
| * @cmdpool: commands pool for extended display list |
| */ |
| struct vsp1_dl_manager { |
| unsigned int index; |
| bool singleshot; |
| struct vsp1_device *vsp1; |
| |
| spinlock_t lock; |
| struct list_head free; |
| struct vsp1_dl_list *active; |
| struct vsp1_dl_list *queued; |
| struct vsp1_dl_list *pending; |
| |
| struct vsp1_dl_body_pool *pool; |
| struct vsp1_dl_cmd_pool *cmdpool; |
| }; |
| |
| /* ----------------------------------------------------------------------------- |
| * Display List Body Management |
| */ |
| |
| /** |
| * vsp1_dl_body_pool_create - Create a pool of bodies from a single allocation |
| * @vsp1: The VSP1 device |
| * @num_bodies: The number of bodies to allocate |
| * @num_entries: The maximum number of entries that a body can contain |
| * @extra_size: Extra allocation provided for the bodies |
| * |
| * Allocate a pool of display list bodies each with enough memory to contain the |
| * requested number of entries plus the @extra_size. |
| * |
| * Return a pointer to a pool on success or NULL if memory can't be allocated. |
| */ |
| struct vsp1_dl_body_pool * |
| vsp1_dl_body_pool_create(struct vsp1_device *vsp1, unsigned int num_bodies, |
| unsigned int num_entries, size_t extra_size) |
| { |
| struct vsp1_dl_body_pool *pool; |
| size_t dlb_size; |
| unsigned int i; |
| |
| pool = kzalloc(sizeof(*pool), GFP_KERNEL); |
| if (!pool) |
| return NULL; |
| |
| pool->vsp1 = vsp1; |
| |
| /* |
| * TODO: 'extra_size' is only used by vsp1_dlm_create(), to allocate |
| * extra memory for the display list header. We need only one header per |
| * display list, not per display list body, thus this allocation is |
| * extraneous and should be reworked in the future. |
| */ |
| dlb_size = num_entries * sizeof(struct vsp1_dl_entry) + extra_size; |
| pool->size = dlb_size * num_bodies; |
| |
| pool->bodies = kcalloc(num_bodies, sizeof(*pool->bodies), GFP_KERNEL); |
| if (!pool->bodies) { |
| kfree(pool); |
| return NULL; |
| } |
| |
| pool->mem = dma_alloc_wc(vsp1->bus_master, pool->size, &pool->dma, |
| GFP_KERNEL); |
| if (!pool->mem) { |
| kfree(pool->bodies); |
| kfree(pool); |
| return NULL; |
| } |
| |
| spin_lock_init(&pool->lock); |
| INIT_LIST_HEAD(&pool->free); |
| |
| for (i = 0; i < num_bodies; ++i) { |
| struct vsp1_dl_body *dlb = &pool->bodies[i]; |
| |
| dlb->pool = pool; |
| dlb->max_entries = num_entries; |
| |
| dlb->dma = pool->dma + i * dlb_size; |
| dlb->entries = pool->mem + i * dlb_size; |
| |
| list_add_tail(&dlb->free, &pool->free); |
| } |
| |
| return pool; |
| } |
| |
| /** |
| * vsp1_dl_body_pool_destroy - Release a body pool |
| * @pool: The body pool |
| * |
| * Release all components of a pool allocation. |
| */ |
| void vsp1_dl_body_pool_destroy(struct vsp1_dl_body_pool *pool) |
| { |
| if (!pool) |
| return; |
| |
| if (pool->mem) |
| dma_free_wc(pool->vsp1->bus_master, pool->size, pool->mem, |
| pool->dma); |
| |
| kfree(pool->bodies); |
| kfree(pool); |
| } |
| |
| /** |
| * vsp1_dl_body_get - Obtain a body from a pool |
| * @pool: The body pool |
| * |
| * Obtain a body from the pool without blocking. |
| * |
| * Returns a display list body or NULL if there are none available. |
| */ |
| struct vsp1_dl_body *vsp1_dl_body_get(struct vsp1_dl_body_pool *pool) |
| { |
| struct vsp1_dl_body *dlb = NULL; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&pool->lock, flags); |
| |
| if (!list_empty(&pool->free)) { |
| dlb = list_first_entry(&pool->free, struct vsp1_dl_body, free); |
| list_del(&dlb->free); |
| refcount_set(&dlb->refcnt, 1); |
| } |
| |
| spin_unlock_irqrestore(&pool->lock, flags); |
| |
| return dlb; |
| } |
| |
| /** |
| * vsp1_dl_body_put - Return a body back to its pool |
| * @dlb: The display list body |
| * |
| * Return a body back to the pool, and reset the num_entries to clear the list. |
| */ |
| void vsp1_dl_body_put(struct vsp1_dl_body *dlb) |
| { |
| unsigned long flags; |
| |
| if (!dlb) |
| return; |
| |
| if (!refcount_dec_and_test(&dlb->refcnt)) |
| return; |
| |
| dlb->num_entries = 0; |
| |
| spin_lock_irqsave(&dlb->pool->lock, flags); |
| list_add_tail(&dlb->free, &dlb->pool->free); |
| spin_unlock_irqrestore(&dlb->pool->lock, flags); |
| } |
| |
| /** |
| * vsp1_dl_body_write - Write a register to a display list body |
| * @dlb: The body |
| * @reg: The register address |
| * @data: The register value |
| * |
| * Write the given register and value to the display list body. The maximum |
| * number of entries that can be written in a body is specified when the body is |
| * allocated by vsp1_dl_body_alloc(). |
| */ |
| void vsp1_dl_body_write(struct vsp1_dl_body *dlb, u32 reg, u32 data) |
| { |
| if (WARN_ONCE(dlb->num_entries >= dlb->max_entries, |
| "DLB size exceeded (max %u)", dlb->max_entries)) |
| return; |
| |
| dlb->entries[dlb->num_entries].addr = reg; |
| dlb->entries[dlb->num_entries].data = data; |
| dlb->num_entries++; |
| } |
| |
| /* ----------------------------------------------------------------------------- |
| * Display List Extended Command Management |
| */ |
| |
| enum vsp1_extcmd_type { |
| VSP1_EXTCMD_AUTODISP, |
| VSP1_EXTCMD_AUTOFLD, |
| }; |
| |
| struct vsp1_extended_command_info { |
| u16 opcode; |
| size_t body_size; |
| }; |
| |
| static const struct vsp1_extended_command_info vsp1_extended_commands[] = { |
| [VSP1_EXTCMD_AUTODISP] = { 0x02, 96 }, |
| [VSP1_EXTCMD_AUTOFLD] = { 0x03, 160 }, |
| }; |
| |
| /** |
| * vsp1_dl_cmd_pool_create - Create a pool of commands from a single allocation |
| * @vsp1: The VSP1 device |
| * @type: The command pool type |
| * @num_cmds: The number of commands to allocate |
| * |
| * Allocate a pool of commands each with enough memory to contain the private |
| * data of each command. The allocation sizes are dependent upon the command |
| * type. |
| * |
| * Return a pointer to the pool on success or NULL if memory can't be allocated. |
| */ |
| static struct vsp1_dl_cmd_pool * |
| vsp1_dl_cmd_pool_create(struct vsp1_device *vsp1, enum vsp1_extcmd_type type, |
| unsigned int num_cmds) |
| { |
| struct vsp1_dl_cmd_pool *pool; |
| unsigned int i; |
| size_t cmd_size; |
| |
| pool = kzalloc(sizeof(*pool), GFP_KERNEL); |
| if (!pool) |
| return NULL; |
| |
| spin_lock_init(&pool->lock); |
| INIT_LIST_HEAD(&pool->free); |
| |
| pool->cmds = kcalloc(num_cmds, sizeof(*pool->cmds), GFP_KERNEL); |
| if (!pool->cmds) { |
| kfree(pool); |
| return NULL; |
| } |
| |
| cmd_size = sizeof(struct vsp1_pre_ext_dl_body) + |
| vsp1_extended_commands[type].body_size; |
| cmd_size = ALIGN(cmd_size, 16); |
| |
| pool->size = cmd_size * num_cmds; |
| pool->mem = dma_alloc_wc(vsp1->bus_master, pool->size, &pool->dma, |
| GFP_KERNEL); |
| if (!pool->mem) { |
| kfree(pool->cmds); |
| kfree(pool); |
| return NULL; |
| } |
| |
| for (i = 0; i < num_cmds; ++i) { |
| struct vsp1_dl_ext_cmd *cmd = &pool->cmds[i]; |
| size_t cmd_offset = i * cmd_size; |
| /* data_offset must be 16 byte aligned for DMA. */ |
| size_t data_offset = sizeof(struct vsp1_pre_ext_dl_body) + |
| cmd_offset; |
| |
| cmd->pool = pool; |
| cmd->opcode = vsp1_extended_commands[type].opcode; |
| |
| /* |
| * TODO: Auto-disp can utilise more than one extended body |
| * command per cmd. |
| */ |
| cmd->num_cmds = 1; |
| cmd->cmds = pool->mem + cmd_offset; |
| cmd->cmd_dma = pool->dma + cmd_offset; |
| |
| cmd->data = pool->mem + data_offset; |
| cmd->data_dma = pool->dma + data_offset; |
| |
| list_add_tail(&cmd->free, &pool->free); |
| } |
| |
| return pool; |
| } |
| |
| static |
| struct vsp1_dl_ext_cmd *vsp1_dl_ext_cmd_get(struct vsp1_dl_cmd_pool *pool) |
| { |
| struct vsp1_dl_ext_cmd *cmd = NULL; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&pool->lock, flags); |
| |
| if (!list_empty(&pool->free)) { |
| cmd = list_first_entry(&pool->free, struct vsp1_dl_ext_cmd, |
| free); |
| list_del(&cmd->free); |
| } |
| |
| spin_unlock_irqrestore(&pool->lock, flags); |
| |
| return cmd; |
| } |
| |
| static void vsp1_dl_ext_cmd_put(struct vsp1_dl_ext_cmd *cmd) |
| { |
| unsigned long flags; |
| |
| if (!cmd) |
| return; |
| |
| /* Reset flags, these mark data usage. */ |
| cmd->flags = 0; |
| |
| spin_lock_irqsave(&cmd->pool->lock, flags); |
| list_add_tail(&cmd->free, &cmd->pool->free); |
| spin_unlock_irqrestore(&cmd->pool->lock, flags); |
| } |
| |
| static void vsp1_dl_ext_cmd_pool_destroy(struct vsp1_dl_cmd_pool *pool) |
| { |
| if (!pool) |
| return; |
| |
| if (pool->mem) |
| dma_free_wc(pool->vsp1->bus_master, pool->size, pool->mem, |
| pool->dma); |
| |
| kfree(pool->cmds); |
| kfree(pool); |
| } |
| |
| struct vsp1_dl_ext_cmd *vsp1_dl_get_pre_cmd(struct vsp1_dl_list *dl) |
| { |
| struct vsp1_dl_manager *dlm = dl->dlm; |
| |
| if (dl->pre_cmd) |
| return dl->pre_cmd; |
| |
| dl->pre_cmd = vsp1_dl_ext_cmd_get(dlm->cmdpool); |
| |
| return dl->pre_cmd; |
| } |
| |
| /* ---------------------------------------------------------------------------- |
| * Display List Transaction Management |
| */ |
| |
| static struct vsp1_dl_list *vsp1_dl_list_alloc(struct vsp1_dl_manager *dlm) |
| { |
| struct vsp1_dl_list *dl; |
| size_t header_offset; |
| |
| dl = kzalloc(sizeof(*dl), GFP_KERNEL); |
| if (!dl) |
| return NULL; |
| |
| INIT_LIST_HEAD(&dl->bodies); |
| dl->dlm = dlm; |
| |
| /* Get a default body for our list. */ |
| dl->body0 = vsp1_dl_body_get(dlm->pool); |
| if (!dl->body0) { |
| kfree(dl); |
| return NULL; |
| } |
| |
| header_offset = dl->body0->max_entries * sizeof(*dl->body0->entries); |
| |
| dl->header = ((void *)dl->body0->entries) + header_offset; |
| dl->dma = dl->body0->dma + header_offset; |
| |
| memset(dl->header, 0, sizeof(*dl->header)); |
| dl->header->lists[0].addr = dl->body0->dma; |
| |
| return dl; |
| } |
| |
| static void vsp1_dl_list_bodies_put(struct vsp1_dl_list *dl) |
| { |
| struct vsp1_dl_body *dlb, *tmp; |
| |
| list_for_each_entry_safe(dlb, tmp, &dl->bodies, list) { |
| list_del(&dlb->list); |
| vsp1_dl_body_put(dlb); |
| } |
| } |
| |
| static void vsp1_dl_list_free(struct vsp1_dl_list *dl) |
| { |
| vsp1_dl_body_put(dl->body0); |
| vsp1_dl_list_bodies_put(dl); |
| |
| kfree(dl); |
| } |
| |
| /** |
| * vsp1_dl_list_get - Get a free display list |
| * @dlm: The display list manager |
| * |
| * Get a display list from the pool of free lists and return it. |
| * |
| * This function must be called without the display list manager lock held. |
| */ |
| struct vsp1_dl_list *vsp1_dl_list_get(struct vsp1_dl_manager *dlm) |
| { |
| struct vsp1_dl_list *dl = NULL; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&dlm->lock, flags); |
| |
| if (!list_empty(&dlm->free)) { |
| dl = list_first_entry(&dlm->free, struct vsp1_dl_list, list); |
| list_del(&dl->list); |
| |
| /* |
| * The display list chain must be initialised to ensure every |
| * display list can assert list_empty() if it is not in a chain. |
| */ |
| INIT_LIST_HEAD(&dl->chain); |
| } |
| |
| spin_unlock_irqrestore(&dlm->lock, flags); |
| |
| return dl; |
| } |
| |
| /* This function must be called with the display list manager lock held.*/ |
| static void __vsp1_dl_list_put(struct vsp1_dl_list *dl) |
| { |
| struct vsp1_dl_list *dl_next; |
| |
| if (!dl) |
| return; |
| |
| /* |
| * Release any linked display-lists which were chained for a single |
| * hardware operation. |
| */ |
| if (dl->has_chain) { |
| list_for_each_entry(dl_next, &dl->chain, chain) |
| __vsp1_dl_list_put(dl_next); |
| } |
| |
| dl->has_chain = false; |
| |
| vsp1_dl_list_bodies_put(dl); |
| |
| vsp1_dl_ext_cmd_put(dl->pre_cmd); |
| vsp1_dl_ext_cmd_put(dl->post_cmd); |
| |
| dl->pre_cmd = NULL; |
| dl->post_cmd = NULL; |
| |
| /* |
| * body0 is reused as as an optimisation as presently every display list |
| * has at least one body, thus we reinitialise the entries list. |
| */ |
| dl->body0->num_entries = 0; |
| |
| list_add_tail(&dl->list, &dl->dlm->free); |
| } |
| |
| /** |
| * vsp1_dl_list_put - Release a display list |
| * @dl: The display list |
| * |
| * Release the display list and return it to the pool of free lists. |
| * |
| * Passing a NULL pointer to this function is safe, in that case no operation |
| * will be performed. |
| */ |
| void vsp1_dl_list_put(struct vsp1_dl_list *dl) |
| { |
| unsigned long flags; |
| |
| if (!dl) |
| return; |
| |
| spin_lock_irqsave(&dl->dlm->lock, flags); |
| __vsp1_dl_list_put(dl); |
| spin_unlock_irqrestore(&dl->dlm->lock, flags); |
| } |
| |
| /** |
| * vsp1_dl_list_get_body0 - Obtain the default body for the display list |
| * @dl: The display list |
| * |
| * Obtain a pointer to the internal display list body allowing this to be passed |
| * directly to configure operations. |
| */ |
| struct vsp1_dl_body *vsp1_dl_list_get_body0(struct vsp1_dl_list *dl) |
| { |
| return dl->body0; |
| } |
| |
| /** |
| * vsp1_dl_list_add_body - Add a body to the display list |
| * @dl: The display list |
| * @dlb: The body |
| * |
| * Add a display list body to a display list. Registers contained in bodies are |
| * processed after registers contained in the main display list, in the order in |
| * which bodies are added. |
| * |
| * Adding a body to a display list passes ownership of the body to the list. The |
| * caller retains its reference to the body when adding it to the display list, |
| * but is not allowed to add new entries to the body. |
| * |
| * The reference must be explicitly released by a call to vsp1_dl_body_put() |
| * when the body isn't needed anymore. |
| */ |
| int vsp1_dl_list_add_body(struct vsp1_dl_list *dl, struct vsp1_dl_body *dlb) |
| { |
| refcount_inc(&dlb->refcnt); |
| |
| list_add_tail(&dlb->list, &dl->bodies); |
| |
| return 0; |
| } |
| |
| /** |
| * vsp1_dl_list_add_chain - Add a display list to a chain |
| * @head: The head display list |
| * @dl: The new display list |
| * |
| * Add a display list to an existing display list chain. The chained lists |
| * will be automatically processed by the hardware without intervention from |
| * the CPU. A display list end interrupt will only complete after the last |
| * display list in the chain has completed processing. |
| * |
| * Adding a display list to a chain passes ownership of the display list to |
| * the head display list item. The chain is released when the head dl item is |
| * put back with __vsp1_dl_list_put(). |
| */ |
| int vsp1_dl_list_add_chain(struct vsp1_dl_list *head, |
| struct vsp1_dl_list *dl) |
| { |
| head->has_chain = true; |
| list_add_tail(&dl->chain, &head->chain); |
| return 0; |
| } |
| |
| static void vsp1_dl_ext_cmd_fill_header(struct vsp1_dl_ext_cmd *cmd) |
| { |
| cmd->cmds[0].opcode = cmd->opcode; |
| cmd->cmds[0].flags = cmd->flags; |
| cmd->cmds[0].address_set = cmd->data_dma; |
| cmd->cmds[0].reserved = 0; |
| } |
| |
| static void vsp1_dl_list_fill_header(struct vsp1_dl_list *dl, bool is_last) |
| { |
| struct vsp1_dl_manager *dlm = dl->dlm; |
| struct vsp1_dl_header_list *hdr = dl->header->lists; |
| struct vsp1_dl_body *dlb; |
| unsigned int num_lists = 0; |
| |
| /* |
| * Fill the header with the display list bodies addresses and sizes. The |
| * address of the first body has already been filled when the display |
| * list was allocated. |
| */ |
| |
| hdr->num_bytes = dl->body0->num_entries |
| * sizeof(*dl->header->lists); |
| |
| list_for_each_entry(dlb, &dl->bodies, list) { |
| num_lists++; |
| hdr++; |
| |
| hdr->addr = dlb->dma; |
| hdr->num_bytes = dlb->num_entries |
| * sizeof(*dl->header->lists); |
| } |
| |
| dl->header->num_lists = num_lists; |
| dl->header->flags = 0; |
| |
| /* |
| * Enable the interrupt for the end of each frame. In continuous mode |
| * chained lists are used with one list per frame, so enable the |
| * interrupt for each list. In singleshot mode chained lists are used |
| * to partition a single frame, so enable the interrupt for the last |
| * list only. |
| */ |
| if (!dlm->singleshot || is_last) |
| dl->header->flags |= VSP1_DLH_INT_ENABLE; |
| |
| /* |
| * In continuous mode enable auto-start for all lists, as the VSP must |
| * loop on the same list until a new one is queued. In singleshot mode |
| * enable auto-start for all lists but the last to chain processing of |
| * partitions without software intervention. |
| */ |
| if (!dlm->singleshot || !is_last) |
| dl->header->flags |= VSP1_DLH_AUTO_START; |
| |
| if (!is_last) { |
| /* |
| * If this is not the last display list in the chain, queue the |
| * next item for automatic processing by the hardware. |
| */ |
| struct vsp1_dl_list *next = list_next_entry(dl, chain); |
| |
| dl->header->next_header = next->dma; |
| } else if (!dlm->singleshot) { |
| /* |
| * if the display list manager works in continuous mode, the VSP |
| * should loop over the display list continuously until |
| * instructed to do otherwise. |
| */ |
| dl->header->next_header = dl->dma; |
| } |
| |
| if (!dl->extension) |
| return; |
| |
| dl->extension->flags = 0; |
| |
| if (dl->pre_cmd) { |
| dl->extension->pre_ext_dl_plist = dl->pre_cmd->cmd_dma; |
| dl->extension->pre_ext_dl_num_cmd = dl->pre_cmd->num_cmds; |
| dl->extension->flags |= VSP1_DLH_EXT_PRE_CMD_EXEC; |
| |
| vsp1_dl_ext_cmd_fill_header(dl->pre_cmd); |
| } |
| |
| if (dl->post_cmd) { |
| dl->extension->post_ext_dl_plist = dl->post_cmd->cmd_dma; |
| dl->extension->post_ext_dl_num_cmd = dl->post_cmd->num_cmds; |
| dl->extension->flags |= VSP1_DLH_EXT_POST_CMD_EXEC; |
| |
| vsp1_dl_ext_cmd_fill_header(dl->post_cmd); |
| } |
| } |
| |
| static bool vsp1_dl_list_hw_update_pending(struct vsp1_dl_manager *dlm) |
| { |
| struct vsp1_device *vsp1 = dlm->vsp1; |
| |
| if (!dlm->queued) |
| return false; |
| |
| /* |
| * Check whether the VSP1 has taken the update. The hardware indicates |
| * this by clearing the UPDHDR bit in the CMD register. |
| */ |
| return !!(vsp1_read(vsp1, VI6_CMD(dlm->index)) & VI6_CMD_UPDHDR); |
| } |
| |
| static void vsp1_dl_list_hw_enqueue(struct vsp1_dl_list *dl) |
| { |
| struct vsp1_dl_manager *dlm = dl->dlm; |
| struct vsp1_device *vsp1 = dlm->vsp1; |
| |
| /* |
| * Program the display list header address. If the hardware is idle |
| * (single-shot mode or first frame in continuous mode) it will then be |
| * started independently. If the hardware is operating, the |
| * VI6_DL_HDR_REF_ADDR register will be updated with the display list |
| * address. |
| */ |
| vsp1_write(vsp1, VI6_DL_HDR_ADDR(dlm->index), dl->dma); |
| } |
| |
| static void vsp1_dl_list_commit_continuous(struct vsp1_dl_list *dl) |
| { |
| struct vsp1_dl_manager *dlm = dl->dlm; |
| |
| /* |
| * If a previous display list has been queued to the hardware but not |
| * processed yet, the VSP can start processing it at any time. In that |
| * case we can't replace the queued list by the new one, as we could |
| * race with the hardware. We thus mark the update as pending, it will |
| * be queued up to the hardware by the frame end interrupt handler. |
| * |
| * If a display list is already pending we simply drop it as the new |
| * display list is assumed to contain a more recent configuration. It is |
| * an error if the already pending list has the |
| * VSP1_DL_FRAME_END_INTERNAL flag set, as there is then a process |
| * waiting for that list to complete. This shouldn't happen as the |
| * waiting process should perform proper locking, but warn just in |
| * case. |
| */ |
| if (vsp1_dl_list_hw_update_pending(dlm)) { |
| WARN_ON(dlm->pending && |
| (dlm->pending->flags & VSP1_DL_FRAME_END_INTERNAL)); |
| __vsp1_dl_list_put(dlm->pending); |
| dlm->pending = dl; |
| return; |
| } |
| |
| /* |
| * Pass the new display list to the hardware and mark it as queued. It |
| * will become active when the hardware starts processing it. |
| */ |
| vsp1_dl_list_hw_enqueue(dl); |
| |
| __vsp1_dl_list_put(dlm->queued); |
| dlm->queued = dl; |
| } |
| |
| static void vsp1_dl_list_commit_singleshot(struct vsp1_dl_list *dl) |
| { |
| struct vsp1_dl_manager *dlm = dl->dlm; |
| |
| /* |
| * When working in single-shot mode, the caller guarantees that the |
| * hardware is idle at this point. Just commit the head display list |
| * to hardware. Chained lists will be started automatically. |
| */ |
| vsp1_dl_list_hw_enqueue(dl); |
| |
| dlm->active = dl; |
| } |
| |
| void vsp1_dl_list_commit(struct vsp1_dl_list *dl, unsigned int dl_flags) |
| { |
| struct vsp1_dl_manager *dlm = dl->dlm; |
| struct vsp1_dl_list *dl_next; |
| unsigned long flags; |
| |
| /* Fill the header for the head and chained display lists. */ |
| vsp1_dl_list_fill_header(dl, list_empty(&dl->chain)); |
| |
| list_for_each_entry(dl_next, &dl->chain, chain) { |
| bool last = list_is_last(&dl_next->chain, &dl->chain); |
| |
| vsp1_dl_list_fill_header(dl_next, last); |
| } |
| |
| dl->flags = dl_flags & ~VSP1_DL_FRAME_END_COMPLETED; |
| |
| spin_lock_irqsave(&dlm->lock, flags); |
| |
| if (dlm->singleshot) |
| vsp1_dl_list_commit_singleshot(dl); |
| else |
| vsp1_dl_list_commit_continuous(dl); |
| |
| spin_unlock_irqrestore(&dlm->lock, flags); |
| } |
| |
| /* ----------------------------------------------------------------------------- |
| * Display List Manager |
| */ |
| |
| /** |
| * vsp1_dlm_irq_frame_end - Display list handler for the frame end interrupt |
| * @dlm: the display list manager |
| * |
| * Return a set of flags that indicates display list completion status. |
| * |
| * The VSP1_DL_FRAME_END_COMPLETED flag indicates that the previous display list |
| * has completed at frame end. If the flag is not returned display list |
| * completion has been delayed by one frame because the display list commit |
| * raced with the frame end interrupt. The function always returns with the flag |
| * set in single-shot mode as display list processing is then not continuous and |
| * races never occur. |
| * |
| * The following flags are only supported for continuous mode. |
| * |
| * The VSP1_DL_FRAME_END_INTERNAL flag indicates that the display list that just |
| * became active had been queued with the internal notification flag. |
| * |
| * The VSP1_DL_FRAME_END_WRITEBACK flag indicates that the previously active |
| * display list had been queued with the writeback flag. |
| */ |
| unsigned int vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm) |
| { |
| struct vsp1_device *vsp1 = dlm->vsp1; |
| u32 status = vsp1_read(vsp1, VI6_STATUS); |
| unsigned int flags = 0; |
| |
| spin_lock(&dlm->lock); |
| |
| /* |
| * The mem-to-mem pipelines work in single-shot mode. No new display |
| * list can be queued, we don't have to do anything. |
| */ |
| if (dlm->singleshot) { |
| __vsp1_dl_list_put(dlm->active); |
| dlm->active = NULL; |
| flags |= VSP1_DL_FRAME_END_COMPLETED; |
| goto done; |
| } |
| |
| /* |
| * If the commit operation raced with the interrupt and occurred after |
| * the frame end event but before interrupt processing, the hardware |
| * hasn't taken the update into account yet. We have to skip one frame |
| * and retry. |
| */ |
| if (vsp1_dl_list_hw_update_pending(dlm)) |
| goto done; |
| |
| /* |
| * Progressive streams report only TOP fields. If we have a BOTTOM |
| * field, we are interlaced, and expect the frame to complete on the |
| * next frame end interrupt. |
| */ |
| if (status & VI6_STATUS_FLD_STD(dlm->index)) |
| goto done; |
| |
| /* |
| * If the active display list has the writeback flag set, the frame |
| * completion marks the end of the writeback capture. Return the |
| * VSP1_DL_FRAME_END_WRITEBACK flag and reset the display list's |
| * writeback flag. |
| */ |
| if (dlm->active && (dlm->active->flags & VSP1_DL_FRAME_END_WRITEBACK)) { |
| flags |= VSP1_DL_FRAME_END_WRITEBACK; |
| dlm->active->flags &= ~VSP1_DL_FRAME_END_WRITEBACK; |
| } |
| |
| /* |
| * The device starts processing the queued display list right after the |
| * frame end interrupt. The display list thus becomes active. |
| */ |
| if (dlm->queued) { |
| if (dlm->queued->flags & VSP1_DL_FRAME_END_INTERNAL) |
| flags |= VSP1_DL_FRAME_END_INTERNAL; |
| dlm->queued->flags &= ~VSP1_DL_FRAME_END_INTERNAL; |
| |
| __vsp1_dl_list_put(dlm->active); |
| dlm->active = dlm->queued; |
| dlm->queued = NULL; |
| flags |= VSP1_DL_FRAME_END_COMPLETED; |
| } |
| |
| /* |
| * Now that the VSP has started processing the queued display list, we |
| * can queue the pending display list to the hardware if one has been |
| * prepared. |
| */ |
| if (dlm->pending) { |
| vsp1_dl_list_hw_enqueue(dlm->pending); |
| dlm->queued = dlm->pending; |
| dlm->pending = NULL; |
| } |
| |
| done: |
| spin_unlock(&dlm->lock); |
| |
| return flags; |
| } |
| |
| /* Hardware Setup */ |
| void vsp1_dlm_setup(struct vsp1_device *vsp1) |
| { |
| unsigned int i; |
| u32 ctrl = (256 << VI6_DL_CTRL_AR_WAIT_SHIFT) |
| | VI6_DL_CTRL_DC2 | VI6_DL_CTRL_DC1 | VI6_DL_CTRL_DC0 |
| | VI6_DL_CTRL_DLE; |
| u32 ext_dl = (0x02 << VI6_DL_EXT_CTRL_POLINT_SHIFT) |
| | VI6_DL_EXT_CTRL_DLPRI | VI6_DL_EXT_CTRL_EXT; |
| |
| if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) { |
| for (i = 0; i < vsp1->info->wpf_count; ++i) |
| vsp1_write(vsp1, VI6_DL_EXT_CTRL(i), ext_dl); |
| } |
| |
| vsp1_write(vsp1, VI6_DL_CTRL, ctrl); |
| vsp1_write(vsp1, VI6_DL_SWAP, VI6_DL_SWAP_LWS); |
| } |
| |
| void vsp1_dlm_reset(struct vsp1_dl_manager *dlm) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&dlm->lock, flags); |
| |
| __vsp1_dl_list_put(dlm->active); |
| __vsp1_dl_list_put(dlm->queued); |
| __vsp1_dl_list_put(dlm->pending); |
| |
| spin_unlock_irqrestore(&dlm->lock, flags); |
| |
| dlm->active = NULL; |
| dlm->queued = NULL; |
| dlm->pending = NULL; |
| } |
| |
| struct vsp1_dl_body *vsp1_dlm_dl_body_get(struct vsp1_dl_manager *dlm) |
| { |
| return vsp1_dl_body_get(dlm->pool); |
| } |
| |
| struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device *vsp1, |
| unsigned int index, |
| unsigned int prealloc) |
| { |
| struct vsp1_dl_manager *dlm; |
| size_t header_size; |
| unsigned int i; |
| |
| dlm = devm_kzalloc(vsp1->dev, sizeof(*dlm), GFP_KERNEL); |
| if (!dlm) |
| return NULL; |
| |
| dlm->index = index; |
| dlm->singleshot = vsp1->info->uapi; |
| dlm->vsp1 = vsp1; |
| |
| spin_lock_init(&dlm->lock); |
| INIT_LIST_HEAD(&dlm->free); |
| |
| /* |
| * Initialize the display list body and allocate DMA memory for the body |
| * and the header. Both are allocated together to avoid memory |
| * fragmentation, with the header located right after the body in |
| * memory. An extra body is allocated on top of the prealloc to account |
| * for the cached body used by the vsp1_pipeline object. |
| */ |
| header_size = vsp1_feature(vsp1, VSP1_HAS_EXT_DL) ? |
| sizeof(struct vsp1_dl_header_extended) : |
| sizeof(struct vsp1_dl_header); |
| |
| header_size = ALIGN(header_size, 8); |
| |
| dlm->pool = vsp1_dl_body_pool_create(vsp1, prealloc + 1, |
| VSP1_DL_NUM_ENTRIES, header_size); |
| if (!dlm->pool) |
| return NULL; |
| |
| for (i = 0; i < prealloc; ++i) { |
| struct vsp1_dl_list *dl; |
| |
| dl = vsp1_dl_list_alloc(dlm); |
| if (!dl) { |
| vsp1_dlm_destroy(dlm); |
| return NULL; |
| } |
| |
| /* The extended header immediately follows the header. */ |
| if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) |
| dl->extension = (void *)dl->header |
| + sizeof(*dl->header); |
| |
| list_add_tail(&dl->list, &dlm->free); |
| } |
| |
| if (vsp1_feature(vsp1, VSP1_HAS_EXT_DL)) { |
| dlm->cmdpool = vsp1_dl_cmd_pool_create(vsp1, |
| VSP1_EXTCMD_AUTOFLD, prealloc); |
| if (!dlm->cmdpool) { |
| vsp1_dlm_destroy(dlm); |
| return NULL; |
| } |
| } |
| |
| return dlm; |
| } |
| |
| void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm) |
| { |
| struct vsp1_dl_list *dl, *next; |
| |
| if (!dlm) |
| return; |
| |
| list_for_each_entry_safe(dl, next, &dlm->free, list) { |
| list_del(&dl->list); |
| vsp1_dl_list_free(dl); |
| } |
| |
| vsp1_dl_body_pool_destroy(dlm->pool); |
| vsp1_dl_ext_cmd_pool_destroy(dlm->cmdpool); |
| } |