drivers/gpu/drm/msm/mdp/mdp5/mdp5_smp.c

   1 /*
   2  * Copyright (c) 2014, The Linux Foundation. All rights reserved.
   3  * Copyright (C) 2013 Red Hat
   4  * Author: Rob Clark <robdclark@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 #include "mdp5_kms.h"
  21 #include "mdp5_smp.h"
  22
  23
  24 /* SMP - Shared Memory Pool
  25  *
  26  * These are shared between all the clients, where each plane in a
  27  * scanout buffer is a SMP client.  Ie. scanout of 3 plane I420 on
  28  * pipe VIG0 => 3 clients: VIG0_Y, VIG0_CB, VIG0_CR.
  29  *
  30  * Based on the size of the attached scanout buffer, a certain # of
  31  * blocks must be allocated to that client out of the shared pool.
  32  *
  33  * In some hw, some blocks are statically allocated for certain pipes
  34  * and CANNOT be re-allocated (eg: MMB0 and MMB1 both tied to RGB0).
  35  *
  36  * For each block that can be dynamically allocated, it can be either
  37  * free, or pending/in-use by a client. The updates happen in three steps:
  38  *
  39  *  1) mdp5_smp_request():
  40  *     When plane scanout is setup, calculate required number of
  41  *     blocks needed per client, and request.  Blocks not inuse or
  42  *     pending by any other client are added to client's pending
  43  *     set.
  44  *
  45  *  2) mdp5_smp_configure():
  46  *     As hw is programmed, before FLUSH, MDP5_SMP_ALLOC registers
  47  *     are configured for the union(pending, inuse)
  48  *
  49  *  3) mdp5_smp_commit():
  50  *     After next vblank, copy pending -> inuse.  Optionally update
  51  *     MDP5_SMP_ALLOC registers if there are newly unused blocks
  52  *
  53  * On the next vblank after changes have been committed to hw, the
  54  * client's pending blocks become it's in-use blocks (and no-longer
  55  * in-use blocks become available to other clients).
  56  *
  57  * btw, hurray for confusing overloaded acronyms!  :-/
  58  *
  59  * NOTE: for atomic modeset/pageflip NONBLOCK operations, step #1
  60  * should happen at (or before)? atomic->check().  And we'd need
  61  * an API to discard previous requests if update is aborted or
  62  * (test-only).
  63  *
  64  * TODO would perhaps be nice to have debugfs to dump out kernel
  65  * inuse and pending state of all clients..
  66  */
  67
  68 struct mdp5_smp {
  69         struct drm_device *dev;
  70
  71         int blk_cnt;
  72         int blk_size;
  73
  74         spinlock_t state_lock;
  75         mdp5_smp_state_t state; /* to track smp allocation amongst pipes: */
  76
  77         struct mdp5_client_smp_state client_state[CID_MAX];
  78 };
  79
  80 static inline
  81 struct mdp5_kms *get_kms(struct mdp5_smp *smp)
  82 {
  83         struct msm_drm_private *priv = smp->dev->dev_private;
  84
  85         return to_mdp5_kms(to_mdp_kms(priv->kms));
  86 }
  87
  88 static inline enum mdp5_client_id pipe2client(enum mdp5_pipe pipe, int plane)
  89 {
  90         WARN_ON(plane >= pipe2nclients(pipe));
  91         switch (pipe) {
  92         case SSPP_VIG0: return CID_VIG0_Y + plane;
  93         case SSPP_VIG1: return CID_VIG1_Y + plane;
  94         case SSPP_VIG2: return CID_VIG2_Y + plane;
  95         case SSPP_RGB0: return CID_RGB0;
  96         case SSPP_RGB1: return CID_RGB1;
  97         case SSPP_RGB2: return CID_RGB2;
  98         case SSPP_DMA0: return CID_DMA0_Y + plane;
  99         case SSPP_DMA1: return CID_DMA1_Y + plane;
 100         case SSPP_VIG3: return CID_VIG3_Y + plane;
 101         case SSPP_RGB3: return CID_RGB3;
 102         default:        return CID_UNUSED;
 103         }
 104 }
 105
 106 /* step #1: update # of blocks pending for the client: */
 107 static int smp_request_block(struct mdp5_smp *smp,
 108                 enum mdp5_client_id cid, int nblks)
 109 {
 110         struct mdp5_kms *mdp5_kms = get_kms(smp);
 111         const struct mdp5_cfg_hw *hw_cfg;
 112         struct mdp5_client_smp_state *ps = &smp->client_state[cid];
 113         int i, ret, avail, cur_nblks, cnt = smp->blk_cnt;
 114         int reserved;
 115         unsigned long flags;
 116
 117         hw_cfg = mdp5_cfg_get_hw_config(mdp5_kms->cfg);
 118         reserved = hw_cfg->smp.reserved[cid];
 119
 120         spin_lock_irqsave(&smp->state_lock, flags);
 121
 122         nblks -= reserved;
 123         if (reserved)
 124                 DBG("%d MMBs allocated (%d reserved)", nblks, reserved);
 125
 126         avail = cnt - bitmap_weight(smp->state, cnt);
 127         if (nblks > avail) {
 128                 dev_err(mdp5_kms->dev->dev, "out of blks (req=%d > avail=%d)\n",
 129                                 nblks, avail);
 130                 ret = -ENOSPC;
 131                 goto fail;
 132         }
 133
 134         cur_nblks = bitmap_weight(ps->pending, cnt);
 135         if (nblks > cur_nblks) {
 136                 /* grow the existing pending reservation: */
 137                 for (i = cur_nblks; i < nblks; i++) {
 138                         int blk = find_first_zero_bit(smp->state, cnt);
 139                         set_bit(blk, ps->pending);
 140                         set_bit(blk, smp->state);
 141                 }
 142         } else {
 143                 /* shrink the existing pending reservation: */
 144                 for (i = cur_nblks; i > nblks; i--) {
 145                         int blk = find_first_bit(ps->pending, cnt);
 146                         clear_bit(blk, ps->pending);
 147                         /* don't clear in global smp_state until _commit() */
 148                 }
 149         }
 150
 151 fail:
 152         spin_unlock_irqrestore(&smp->state_lock, flags);
 153         return 0;
 154 }
 155
 156 static void set_fifo_thresholds(struct mdp5_smp *smp,
 157                 enum mdp5_pipe pipe, int nblks)
 158 {
 159         struct mdp5_kms *mdp5_kms = get_kms(smp);
 160         u32 smp_entries_per_blk = smp->blk_size / (128 / BITS_PER_BYTE);
 161         u32 val;
 162
 163         /* 1/4 of SMP pool that is being fetched */
 164         val = (nblks * smp_entries_per_blk) / 4;
 165
 166         mdp5_write(mdp5_kms, REG_MDP5_PIPE_REQPRIO_FIFO_WM_0(pipe), val * 1);
 167         mdp5_write(mdp5_kms, REG_MDP5_PIPE_REQPRIO_FIFO_WM_1(pipe), val * 2);
 168         mdp5_write(mdp5_kms, REG_MDP5_PIPE_REQPRIO_FIFO_WM_2(pipe), val * 3);
 169 }
 170
 171 /*
 172  * NOTE: looks like if horizontal decimation is used (if we supported that)
 173  * then the width used to calculate SMP block requirements is the post-
 174  * decimated width.  Ie. SMP buffering sits downstream of decimation (which
 175  * presumably happens during the dma from scanout buffer).
 176  */
 177 int mdp5_smp_request(struct mdp5_smp *smp, enum mdp5_pipe pipe, u32 fmt, u32 width)
 178 {
 179         struct mdp5_kms *mdp5_kms = get_kms(smp);
 180         struct drm_device *dev = mdp5_kms->dev;
 181         int rev = mdp5_cfg_get_hw_rev(mdp5_kms->cfg);
 182         int i, hsub, nplanes, nlines, nblks, ret;
 183
 184         nplanes = drm_format_num_planes(fmt);
 185         hsub = drm_format_horz_chroma_subsampling(fmt);
 186
 187         /* different if BWC (compressed framebuffer?) enabled: */
 188         nlines = 2;
 189
 190         for (i = 0, nblks = 0; i < nplanes; i++) {
 191                 int n, fetch_stride, cpp;
 192
 193                 cpp = drm_format_plane_cpp(fmt, i);
 194                 fetch_stride = width * cpp / (i ? hsub : 1);
 195
 196                 n = DIV_ROUND_UP(fetch_stride * nlines, smp->blk_size);
 197
 198                 /* for hw rev v1.00 */
 199                 if (rev == 0)
 200                         n = roundup_pow_of_two(n);
 201
 202                 DBG("%s[%d]: request %d SMP blocks", pipe2name(pipe), i, n);
 203                 ret = smp_request_block(smp, pipe2client(pipe, i), n);
 204                 if (ret) {
 205                         dev_err(dev->dev, "Cannot allocate %d SMP blocks: %d\n",
 206                                         n, ret);
 207                         return ret;
 208                 }
 209
 210                 nblks += n;
 211         }
 212
 213         set_fifo_thresholds(smp, pipe, nblks);
 214
 215         return 0;
 216 }
 217
 218 /* Release SMP blocks for all clients of the pipe */
 219 void mdp5_smp_release(struct mdp5_smp *smp, enum mdp5_pipe pipe)
 220 {
 221         int i, nblks;
 222
 223         for (i = 0, nblks = 0; i < pipe2nclients(pipe); i++)
 224                 smp_request_block(smp, pipe2client(pipe, i), 0);
 225         set_fifo_thresholds(smp, pipe, 0);
 226 }
 227
 228 static void update_smp_state(struct mdp5_smp *smp,
 229                 enum mdp5_client_id cid, mdp5_smp_state_t *assigned)
 230 {
 231         struct mdp5_kms *mdp5_kms = get_kms(smp);
 232         int cnt = smp->blk_cnt;
 233         u32 blk, val;
 234
 235         for_each_set_bit(blk, *assigned, cnt) {
 236                 int idx = blk / 3;
 237                 int fld = blk % 3;
 238
 239                 val = mdp5_read(mdp5_kms, REG_MDP5_SMP_ALLOC_W_REG(idx));
 240
 241                 switch (fld) {
 242                 case 0:
 243                         val &= ~MDP5_SMP_ALLOC_W_REG_CLIENT0__MASK;
 244                         val |= MDP5_SMP_ALLOC_W_REG_CLIENT0(cid);
 245                         break;
 246                 case 1:
 247                         val &= ~MDP5_SMP_ALLOC_W_REG_CLIENT1__MASK;
 248                         val |= MDP5_SMP_ALLOC_W_REG_CLIENT1(cid);
 249                         break;
 250                 case 2:
 251                         val &= ~MDP5_SMP_ALLOC_W_REG_CLIENT2__MASK;
 252                         val |= MDP5_SMP_ALLOC_W_REG_CLIENT2(cid);
 253                         break;
 254                 }
 255
 256                 mdp5_write(mdp5_kms, REG_MDP5_SMP_ALLOC_W_REG(idx), val);
 257                 mdp5_write(mdp5_kms, REG_MDP5_SMP_ALLOC_R_REG(idx), val);
 258         }
 259 }
 260
 261 /* step #2: configure hw for union(pending, inuse): */
 262 void mdp5_smp_configure(struct mdp5_smp *smp, enum mdp5_pipe pipe)
 263 {
 264         int cnt = smp->blk_cnt;
 265         mdp5_smp_state_t assigned;
 266         int i;
 267
 268         for (i = 0; i < pipe2nclients(pipe); i++) {
 269                 enum mdp5_client_id cid = pipe2client(pipe, i);
 270                 struct mdp5_client_smp_state *ps = &smp->client_state[cid];
 271
 272                 bitmap_or(assigned, ps->inuse, ps->pending, cnt);
 273                 update_smp_state(smp, cid, &assigned);
 274         }
 275 }
 276
 277 /* step #3: after vblank, copy pending -> inuse: */
 278 void mdp5_smp_commit(struct mdp5_smp *smp, enum mdp5_pipe pipe)
 279 {
 280         int cnt = smp->blk_cnt;
 281         mdp5_smp_state_t released;
 282         int i;
 283
 284         for (i = 0; i < pipe2nclients(pipe); i++) {
 285                 enum mdp5_client_id cid = pipe2client(pipe, i);
 286                 struct mdp5_client_smp_state *ps = &smp->client_state[cid];
 287
 288                 /*
 289                  * Figure out if there are any blocks we where previously
 290                  * using, which can be released and made available to other
 291                  * clients:
 292                  */
 293                 if (bitmap_andnot(released, ps->inuse, ps->pending, cnt)) {
 294                         unsigned long flags;
 295
 296                         spin_lock_irqsave(&smp->state_lock, flags);
 297                         /* clear released blocks: */
 298                         bitmap_andnot(smp->state, smp->state, released, cnt);
 299                         spin_unlock_irqrestore(&smp->state_lock, flags);
 300
 301                         update_smp_state(smp, CID_UNUSED, &released);
 302                 }
 303
 304                 bitmap_copy(ps->inuse, ps->pending, cnt);
 305         }
 306 }
 307
 308 void mdp5_smp_destroy(struct mdp5_smp *smp)
 309 {
 310         kfree(smp);
 311 }
 312
 313 struct mdp5_smp *mdp5_smp_init(struct drm_device *dev, const struct mdp5_smp_block *cfg)
 314 {
 315         struct mdp5_smp *smp = NULL;
 316         int ret;
 317
 318         smp = kzalloc(sizeof(*smp), GFP_KERNEL);
 319         if (unlikely(!smp)) {
 320                 ret = -ENOMEM;
 321                 goto fail;
 322         }
 323
 324         smp->dev = dev;
 325         smp->blk_cnt = cfg->mmb_count;
 326         smp->blk_size = cfg->mmb_size;
 327
 328         /* statically tied MMBs cannot be re-allocated: */
 329         bitmap_copy(smp->state, cfg->reserved_state, smp->blk_cnt);
 330         spin_lock_init(&smp->state_lock);
 331
 332         return smp;
 333 fail:
 334         if (smp)
 335                 mdp5_smp_destroy(smp);
 336
 337         return ERR_PTR(ret);
 338 }