mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-27 19:25:05 +07:00
dfe9cfccb2
The standard kernel integer types are [us]{8,16,32}. Use them instead of
the u?int{8,16,32}_t types.
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Sebastian Reichel <sebastian.reichel@collabora.co.uk>
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
331 lines
10 KiB
C
331 lines
10 KiB
C
/*
|
|
* TILER container manager specification and support functions for TI
|
|
* TILER driver.
|
|
*
|
|
* Author: Lajos Molnar <molnar@ti.com>
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* * Neither the name of Texas Instruments Incorporated nor the names of
|
|
* its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef TCM_H
|
|
#define TCM_H
|
|
|
|
struct tcm;
|
|
|
|
/* point */
|
|
struct tcm_pt {
|
|
u16 x;
|
|
u16 y;
|
|
};
|
|
|
|
/* 1d or 2d area */
|
|
struct tcm_area {
|
|
bool is2d; /* whether area is 1d or 2d */
|
|
struct tcm *tcm; /* parent */
|
|
struct tcm_pt p0;
|
|
struct tcm_pt p1;
|
|
};
|
|
|
|
struct tcm {
|
|
u16 width, height; /* container dimensions */
|
|
int lut_id; /* Lookup table identifier */
|
|
|
|
unsigned int y_offset; /* offset to use for y coordinates */
|
|
|
|
spinlock_t lock;
|
|
unsigned long *bitmap;
|
|
size_t map_size;
|
|
|
|
/* function table */
|
|
s32 (*reserve_2d)(struct tcm *tcm, u16 height, u16 width, u16 align,
|
|
s16 offset, u16 slot_bytes,
|
|
struct tcm_area *area);
|
|
s32 (*reserve_1d)(struct tcm *tcm, u32 slots, struct tcm_area *area);
|
|
s32 (*free)(struct tcm *tcm, struct tcm_area *area);
|
|
void (*deinit)(struct tcm *tcm);
|
|
};
|
|
|
|
/*=============================================================================
|
|
BASIC TILER CONTAINER MANAGER INTERFACE
|
|
=============================================================================*/
|
|
|
|
/*
|
|
* NOTE:
|
|
*
|
|
* Since some basic parameter checking is done outside the TCM algorithms,
|
|
* TCM implementation do NOT have to check the following:
|
|
*
|
|
* area pointer is NULL
|
|
* width and height fits within container
|
|
* number of pages is more than the size of the container
|
|
*
|
|
*/
|
|
|
|
struct tcm *sita_init(u16 width, u16 height);
|
|
|
|
|
|
/**
|
|
* Deinitialize tiler container manager.
|
|
*
|
|
* @param tcm Pointer to container manager.
|
|
*
|
|
* @return 0 on success, non-0 error value on error. The call
|
|
* should free as much memory as possible and meaningful
|
|
* even on failure. Some error codes: -ENODEV: invalid
|
|
* manager.
|
|
*/
|
|
static inline void tcm_deinit(struct tcm *tcm)
|
|
{
|
|
if (tcm)
|
|
tcm->deinit(tcm);
|
|
}
|
|
|
|
/**
|
|
* Reserves a 2D area in the container.
|
|
*
|
|
* @param tcm Pointer to container manager.
|
|
* @param height Height(in pages) of area to be reserved.
|
|
* @param width Width(in pages) of area to be reserved.
|
|
* @param align Alignment requirement for top-left corner of area. Not
|
|
* all values may be supported by the container manager,
|
|
* but it must support 0 (1), 32 and 64.
|
|
* 0 value is equivalent to 1.
|
|
* @param offset Offset requirement, in bytes. This is the offset
|
|
* from a 4KiB aligned virtual address.
|
|
* @param slot_bytes Width of slot in bytes
|
|
* @param area Pointer to where the reserved area should be stored.
|
|
*
|
|
* @return 0 on success. Non-0 error code on failure. Also,
|
|
* the tcm field of the area will be set to NULL on
|
|
* failure. Some error codes: -ENODEV: invalid manager,
|
|
* -EINVAL: invalid area, -ENOMEM: not enough space for
|
|
* allocation.
|
|
*/
|
|
static inline s32 tcm_reserve_2d(struct tcm *tcm, u16 width, u16 height,
|
|
u16 align, s16 offset, u16 slot_bytes,
|
|
struct tcm_area *area)
|
|
{
|
|
/* perform rudimentary error checking */
|
|
s32 res = tcm == NULL ? -ENODEV :
|
|
(area == NULL || width == 0 || height == 0 ||
|
|
/* align must be a 2 power */
|
|
(align & (align - 1))) ? -EINVAL :
|
|
(height > tcm->height || width > tcm->width) ? -ENOMEM : 0;
|
|
|
|
if (!res) {
|
|
area->is2d = true;
|
|
res = tcm->reserve_2d(tcm, height, width, align, offset,
|
|
slot_bytes, area);
|
|
area->tcm = res ? NULL : tcm;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Reserves a 1D area in the container.
|
|
*
|
|
* @param tcm Pointer to container manager.
|
|
* @param slots Number of (contiguous) slots to reserve.
|
|
* @param area Pointer to where the reserved area should be stored.
|
|
*
|
|
* @return 0 on success. Non-0 error code on failure. Also,
|
|
* the tcm field of the area will be set to NULL on
|
|
* failure. Some error codes: -ENODEV: invalid manager,
|
|
* -EINVAL: invalid area, -ENOMEM: not enough space for
|
|
* allocation.
|
|
*/
|
|
static inline s32 tcm_reserve_1d(struct tcm *tcm, u32 slots,
|
|
struct tcm_area *area)
|
|
{
|
|
/* perform rudimentary error checking */
|
|
s32 res = tcm == NULL ? -ENODEV :
|
|
(area == NULL || slots == 0) ? -EINVAL :
|
|
slots > (tcm->width * (u32) tcm->height) ? -ENOMEM : 0;
|
|
|
|
if (!res) {
|
|
area->is2d = false;
|
|
res = tcm->reserve_1d(tcm, slots, area);
|
|
area->tcm = res ? NULL : tcm;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Free a previously reserved area from the container.
|
|
*
|
|
* @param area Pointer to area reserved by a prior call to
|
|
* tcm_reserve_1d or tcm_reserve_2d call, whether
|
|
* it was successful or not. (Note: all fields of
|
|
* the structure must match.)
|
|
*
|
|
* @return 0 on success. Non-0 error code on failure. Also, the tcm
|
|
* field of the area is set to NULL on success to avoid subsequent
|
|
* freeing. This call will succeed even if supplying
|
|
* the area from a failed reserved call.
|
|
*/
|
|
static inline s32 tcm_free(struct tcm_area *area)
|
|
{
|
|
s32 res = 0; /* free succeeds by default */
|
|
|
|
if (area && area->tcm) {
|
|
res = area->tcm->free(area->tcm, area);
|
|
if (res == 0)
|
|
area->tcm = NULL;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/*=============================================================================
|
|
HELPER FUNCTION FOR ANY TILER CONTAINER MANAGER
|
|
=============================================================================*/
|
|
|
|
/**
|
|
* This method slices off the topmost 2D slice from the parent area, and stores
|
|
* it in the 'slice' parameter. The 'parent' parameter will get modified to
|
|
* contain the remaining portion of the area. If the whole parent area can
|
|
* fit in a 2D slice, its tcm pointer is set to NULL to mark that it is no
|
|
* longer a valid area.
|
|
*
|
|
* @param parent Pointer to a VALID parent area that will get modified
|
|
* @param slice Pointer to the slice area that will get modified
|
|
*/
|
|
static inline void tcm_slice(struct tcm_area *parent, struct tcm_area *slice)
|
|
{
|
|
*slice = *parent;
|
|
|
|
/* check if we need to slice */
|
|
if (slice->tcm && !slice->is2d &&
|
|
slice->p0.y != slice->p1.y &&
|
|
(slice->p0.x || (slice->p1.x != slice->tcm->width - 1))) {
|
|
/* set end point of slice (start always remains) */
|
|
slice->p1.x = slice->tcm->width - 1;
|
|
slice->p1.y = (slice->p0.x) ? slice->p0.y : slice->p1.y - 1;
|
|
/* adjust remaining area */
|
|
parent->p0.x = 0;
|
|
parent->p0.y = slice->p1.y + 1;
|
|
} else {
|
|
/* mark this as the last slice */
|
|
parent->tcm = NULL;
|
|
}
|
|
}
|
|
|
|
/* Verify if a tcm area is logically valid */
|
|
static inline bool tcm_area_is_valid(struct tcm_area *area)
|
|
{
|
|
return area && area->tcm &&
|
|
/* coordinate bounds */
|
|
area->p1.x < area->tcm->width &&
|
|
area->p1.y < area->tcm->height &&
|
|
area->p0.y <= area->p1.y &&
|
|
/* 1D coordinate relationship + p0.x check */
|
|
((!area->is2d &&
|
|
area->p0.x < area->tcm->width &&
|
|
area->p0.x + area->p0.y * area->tcm->width <=
|
|
area->p1.x + area->p1.y * area->tcm->width) ||
|
|
/* 2D coordinate relationship */
|
|
(area->is2d &&
|
|
area->p0.x <= area->p1.x));
|
|
}
|
|
|
|
/* see if a coordinate is within an area */
|
|
static inline bool __tcm_is_in(struct tcm_pt *p, struct tcm_area *a)
|
|
{
|
|
u16 i;
|
|
|
|
if (a->is2d) {
|
|
return p->x >= a->p0.x && p->x <= a->p1.x &&
|
|
p->y >= a->p0.y && p->y <= a->p1.y;
|
|
} else {
|
|
i = p->x + p->y * a->tcm->width;
|
|
return i >= a->p0.x + a->p0.y * a->tcm->width &&
|
|
i <= a->p1.x + a->p1.y * a->tcm->width;
|
|
}
|
|
}
|
|
|
|
/* calculate area width */
|
|
static inline u16 __tcm_area_width(struct tcm_area *area)
|
|
{
|
|
return area->p1.x - area->p0.x + 1;
|
|
}
|
|
|
|
/* calculate area height */
|
|
static inline u16 __tcm_area_height(struct tcm_area *area)
|
|
{
|
|
return area->p1.y - area->p0.y + 1;
|
|
}
|
|
|
|
/* calculate number of slots in an area */
|
|
static inline u16 __tcm_sizeof(struct tcm_area *area)
|
|
{
|
|
return area->is2d ?
|
|
__tcm_area_width(area) * __tcm_area_height(area) :
|
|
(area->p1.x - area->p0.x + 1) + (area->p1.y - area->p0.y) *
|
|
area->tcm->width;
|
|
}
|
|
#define tcm_sizeof(area) __tcm_sizeof(&(area))
|
|
#define tcm_awidth(area) __tcm_area_width(&(area))
|
|
#define tcm_aheight(area) __tcm_area_height(&(area))
|
|
#define tcm_is_in(pt, area) __tcm_is_in(&(pt), &(area))
|
|
|
|
/* limit a 1D area to the first N pages */
|
|
static inline s32 tcm_1d_limit(struct tcm_area *a, u32 num_pg)
|
|
{
|
|
if (__tcm_sizeof(a) < num_pg)
|
|
return -ENOMEM;
|
|
if (!num_pg)
|
|
return -EINVAL;
|
|
|
|
a->p1.x = (a->p0.x + num_pg - 1) % a->tcm->width;
|
|
a->p1.y = a->p0.y + ((a->p0.x + num_pg - 1) / a->tcm->width);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Iterate through 2D slices of a valid area. Behaves
|
|
* syntactically as a for(;;) statement.
|
|
*
|
|
* @param var Name of a local variable of type 'struct
|
|
* tcm_area *' that will get modified to
|
|
* contain each slice.
|
|
* @param area Pointer to the VALID parent area. This
|
|
* structure will not get modified
|
|
* throughout the loop.
|
|
*
|
|
*/
|
|
#define tcm_for_each_slice(var, area, safe) \
|
|
for (safe = area, \
|
|
tcm_slice(&safe, &var); \
|
|
var.tcm; tcm_slice(&safe, &var))
|
|
|
|
#endif
|