// SPDX-License-Identifier: GPL-2.0+ /* * vsp1_dl.c -- R-Car VSP1 Display List * * Copyright (C) 2015 Renesas Corporation * * Contact: Laurent Pinchart ([email protected]) */ #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 … #define VSP1_DLH_INT_ENABLE … #define VSP1_DLH_AUTO_START … #define VSP1_DLH_EXT_PRE_CMD_EXEC … #define VSP1_DLH_EXT_POST_CMD_EXEC … struct vsp1_dl_header_list { … } __packed; struct vsp1_dl_header { … } __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 { … } __packed; struct vsp1_dl_header_extended { … } __packed; struct vsp1_dl_entry { … } __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 { … } __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 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 { … }; /** * struct vsp1_dl_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 { … }; /** * 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 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 { … }; /* ----------------------------------------------------------------------------- * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /* ----------------------------------------------------------------------------- * Display List Extended Command Management */ enum vsp1_extcmd_type { … }; struct vsp1_extended_command_info { … }; static const struct vsp1_extended_command_info vsp1_extended_commands[] = …; /** * 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) { … } static struct vsp1_dl_ext_cmd *vsp1_dl_ext_cmd_get(struct vsp1_dl_cmd_pool *pool) { … } static void vsp1_dl_ext_cmd_put(struct vsp1_dl_ext_cmd *cmd) { … } static void vsp1_dl_ext_cmd_pool_destroy(struct vsp1_dl_cmd_pool *pool) { … } struct vsp1_dl_ext_cmd *vsp1_dl_get_pre_cmd(struct vsp1_dl_list *dl) { … } /* ---------------------------------------------------------------------------- * Display List Transaction Management */ static struct vsp1_dl_list *vsp1_dl_list_alloc(struct vsp1_dl_manager *dlm) { … } static void vsp1_dl_list_bodies_put(struct vsp1_dl_list *dl) { … } static void vsp1_dl_list_free(struct vsp1_dl_list *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) { … } /* This function must be called with the display list manager lock held.*/ static void __vsp1_dl_list_put(struct vsp1_dl_list *dl) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } static void vsp1_dl_ext_cmd_fill_header(struct vsp1_dl_ext_cmd *cmd) { … } static void vsp1_dl_list_fill_header(struct vsp1_dl_list *dl, bool is_last) { … } static bool vsp1_dl_list_hw_update_pending(struct vsp1_dl_manager *dlm) { … } static void vsp1_dl_list_hw_enqueue(struct vsp1_dl_list *dl) { … } static void vsp1_dl_list_commit_continuous(struct vsp1_dl_list *dl) { … } static void vsp1_dl_list_commit_singleshot(struct vsp1_dl_list *dl) { … } void vsp1_dl_list_commit(struct vsp1_dl_list *dl, unsigned int dl_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) { … } /* Hardware Setup */ void vsp1_dlm_setup(struct vsp1_device *vsp1) { … } void vsp1_dlm_reset(struct vsp1_dl_manager *dlm) { … } struct vsp1_dl_body *vsp1_dlm_dl_body_get(struct vsp1_dl_manager *dlm) { … } struct vsp1_dl_manager *vsp1_dlm_create(struct vsp1_device *vsp1, unsigned int index, unsigned int prealloc) { … } void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm) { … }
Codebase Browser
linux