OSCL-LXR linux-6.0.1/​drivers/​gpu/​drm/​omapdrm/​tcm.h	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

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

This page was automatically generated by the 2.1.0 LXR engine. The LXR team