123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422 |
- /*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
- * Copyright (C) 2013 Red Hat
- * Author: Rob Clark <robdclark@gmail.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program. If not, see <http://www.gnu.org/licenses/>.
- */
- #include "mdp5_kms.h"
- #include "mdp5_smp.h"
- /* SMP - Shared Memory Pool
- *
- * These are shared between all the clients, where each plane in a
- * scanout buffer is a SMP client. Ie. scanout of 3 plane I420 on
- * pipe VIG0 => 3 clients: VIG0_Y, VIG0_CB, VIG0_CR.
- *
- * Based on the size of the attached scanout buffer, a certain # of
- * blocks must be allocated to that client out of the shared pool.
- *
- * In some hw, some blocks are statically allocated for certain pipes
- * and CANNOT be re-allocated (eg: MMB0 and MMB1 both tied to RGB0).
- *
- * For each block that can be dynamically allocated, it can be either
- * free:
- * The block is free.
- *
- * pending:
- * The block is allocated to some client and not free.
- *
- * configured:
- * The block is allocated to some client, and assigned to that
- * client in MDP5_MDP_SMP_ALLOC registers.
- *
- * inuse:
- * The block is being actively used by a client.
- *
- * The updates happen in the following steps:
- *
- * 1) mdp5_smp_request():
- * When plane scanout is setup, calculate required number of
- * blocks needed per client, and request. Blocks neither inuse nor
- * configured nor pending by any other client are added to client's
- * pending set.
- * For shrinking, blocks in pending but not in configured can be freed
- * directly, but those already in configured will be freed later by
- * mdp5_smp_commit.
- *
- * 2) mdp5_smp_configure():
- * As hw is programmed, before FLUSH, MDP5_MDP_SMP_ALLOC registers
- * are configured for the union(pending, inuse)
- * Current pending is copied to configured.
- * It is assumed that mdp5_smp_request and mdp5_smp_configure not run
- * concurrently for the same pipe.
- *
- * 3) mdp5_smp_commit():
- * After next vblank, copy configured -> inuse. Optionally update
- * MDP5_SMP_ALLOC registers if there are newly unused blocks
- *
- * 4) mdp5_smp_release():
- * Must be called after the pipe is disabled and no longer uses any SMB
- *
- * On the next vblank after changes have been committed to hw, the
- * client's pending blocks become it's in-use blocks (and no-longer
- * in-use blocks become available to other clients).
- *
- * btw, hurray for confusing overloaded acronyms! :-/
- *
- * NOTE: for atomic modeset/pageflip NONBLOCK operations, step #1
- * should happen at (or before)? atomic->check(). And we'd need
- * an API to discard previous requests if update is aborted or
- * (test-only).
- *
- * TODO would perhaps be nice to have debugfs to dump out kernel
- * inuse and pending state of all clients..
- */
- struct mdp5_smp {
- struct drm_device *dev;
- uint8_t reserved[MAX_CLIENTS]; /* fixed MMBs allocation per client */
- int blk_cnt;
- int blk_size;
- spinlock_t state_lock;
- mdp5_smp_state_t state; /* to track smp allocation amongst pipes: */
- struct mdp5_client_smp_state client_state[MAX_CLIENTS];
- };
- static void update_smp_state(struct mdp5_smp *smp,
- u32 cid, mdp5_smp_state_t *assigned);
- static inline
- struct mdp5_kms *get_kms(struct mdp5_smp *smp)
- {
- struct msm_drm_private *priv = smp->dev->dev_private;
- return to_mdp5_kms(to_mdp_kms(priv->kms));
- }
- static inline u32 pipe2client(enum mdp5_pipe pipe, int plane)
- {
- #define CID_UNUSED 0
- if (WARN_ON(plane >= pipe2nclients(pipe)))
- return CID_UNUSED;
- /*
- * Note on SMP clients:
- * For ViG pipes, fetch Y/Cr/Cb-components clients are always
- * consecutive, and in that order.
- *
- * e.g.:
- * if mdp5_cfg->smp.clients[SSPP_VIG0] = N,
- * Y plane's client ID is N
- * Cr plane's client ID is N + 1
- * Cb plane's client ID is N + 2
- */
- return mdp5_cfg->smp.clients[pipe] + plane;
- }
- /* step #1: update # of blocks pending for the client: */
- static int smp_request_block(struct mdp5_smp *smp,
- u32 cid, int nblks)
- {
- struct mdp5_kms *mdp5_kms = get_kms(smp);
- struct mdp5_client_smp_state *ps = &smp->client_state[cid];
- int i, ret, avail, cur_nblks, cnt = smp->blk_cnt;
- uint8_t reserved;
- unsigned long flags;
- reserved = smp->reserved[cid];
- spin_lock_irqsave(&smp->state_lock, flags);
- if (reserved) {
- nblks = max(0, nblks - reserved);
- DBG("%d MMBs allocated (%d reserved)", nblks, reserved);
- }
- avail = cnt - bitmap_weight(smp->state, cnt);
- if (nblks > avail) {
- dev_err(mdp5_kms->dev->dev, "out of blks (req=%d > avail=%d)\n",
- nblks, avail);
- ret = -ENOSPC;
- goto fail;
- }
- cur_nblks = bitmap_weight(ps->pending, cnt);
- if (nblks > cur_nblks) {
- /* grow the existing pending reservation: */
- for (i = cur_nblks; i < nblks; i++) {
- int blk = find_first_zero_bit(smp->state, cnt);
- set_bit(blk, ps->pending);
- set_bit(blk, smp->state);
- }
- } else {
- /* shrink the existing pending reservation: */
- for (i = cur_nblks; i > nblks; i--) {
- int blk = find_first_bit(ps->pending, cnt);
- clear_bit(blk, ps->pending);
- /* clear in global smp_state if not in configured
- * otherwise until _commit()
- */
- if (!test_bit(blk, ps->configured))
- clear_bit(blk, smp->state);
- }
- }
- fail:
- spin_unlock_irqrestore(&smp->state_lock, flags);
- return 0;
- }
- static void set_fifo_thresholds(struct mdp5_smp *smp,
- enum mdp5_pipe pipe, int nblks)
- {
- struct mdp5_kms *mdp5_kms = get_kms(smp);
- u32 smp_entries_per_blk = smp->blk_size / (128 / BITS_PER_BYTE);
- u32 val;
- /* 1/4 of SMP pool that is being fetched */
- val = (nblks * smp_entries_per_blk) / 4;
- mdp5_write(mdp5_kms, REG_MDP5_PIPE_REQPRIO_FIFO_WM_0(pipe), val * 1);
- mdp5_write(mdp5_kms, REG_MDP5_PIPE_REQPRIO_FIFO_WM_1(pipe), val * 2);
- mdp5_write(mdp5_kms, REG_MDP5_PIPE_REQPRIO_FIFO_WM_2(pipe), val * 3);
- }
- /*
- * NOTE: looks like if horizontal decimation is used (if we supported that)
- * then the width used to calculate SMP block requirements is the post-
- * decimated width. Ie. SMP buffering sits downstream of decimation (which
- * presumably happens during the dma from scanout buffer).
- */
- int mdp5_smp_request(struct mdp5_smp *smp, enum mdp5_pipe pipe,
- const struct mdp_format *format, u32 width, bool hdecim)
- {
- struct mdp5_kms *mdp5_kms = get_kms(smp);
- struct drm_device *dev = mdp5_kms->dev;
- int rev = mdp5_cfg_get_hw_rev(mdp5_kms->cfg);
- int i, hsub, nplanes, nlines, nblks, ret;
- u32 fmt = format->base.pixel_format;
- nplanes = drm_format_num_planes(fmt);
- hsub = drm_format_horz_chroma_subsampling(fmt);
- /* different if BWC (compressed framebuffer?) enabled: */
- nlines = 2;
- /* Newer MDPs have split/packing logic, which fetches sub-sampled
- * U and V components (splits them from Y if necessary) and packs
- * them together, writes to SMP using a single client.
- */
- if ((rev > 0) && (format->chroma_sample > CHROMA_FULL)) {
- fmt = DRM_FORMAT_NV24;
- nplanes = 2;
- /* if decimation is enabled, HW decimates less on the
- * sub sampled chroma components
- */
- if (hdecim && (hsub > 1))
- hsub = 1;
- }
- for (i = 0, nblks = 0; i < nplanes; i++) {
- int n, fetch_stride, cpp;
- cpp = drm_format_plane_cpp(fmt, i);
- fetch_stride = width * cpp / (i ? hsub : 1);
- n = DIV_ROUND_UP(fetch_stride * nlines, smp->blk_size);
- /* for hw rev v1.00 */
- if (rev == 0)
- n = roundup_pow_of_two(n);
- DBG("%s[%d]: request %d SMP blocks", pipe2name(pipe), i, n);
- ret = smp_request_block(smp, pipe2client(pipe, i), n);
- if (ret) {
- dev_err(dev->dev, "Cannot allocate %d SMP blocks: %d\n",
- n, ret);
- return ret;
- }
- nblks += n;
- }
- set_fifo_thresholds(smp, pipe, nblks);
- return 0;
- }
- /* Release SMP blocks for all clients of the pipe */
- void mdp5_smp_release(struct mdp5_smp *smp, enum mdp5_pipe pipe)
- {
- int i;
- unsigned long flags;
- int cnt = smp->blk_cnt;
- for (i = 0; i < pipe2nclients(pipe); i++) {
- mdp5_smp_state_t assigned;
- u32 cid = pipe2client(pipe, i);
- struct mdp5_client_smp_state *ps = &smp->client_state[cid];
- spin_lock_irqsave(&smp->state_lock, flags);
- /* clear hw assignment */
- bitmap_or(assigned, ps->inuse, ps->configured, cnt);
- update_smp_state(smp, CID_UNUSED, &assigned);
- /* free to global pool */
- bitmap_andnot(smp->state, smp->state, ps->pending, cnt);
- bitmap_andnot(smp->state, smp->state, assigned, cnt);
- /* clear client's infor */
- bitmap_zero(ps->pending, cnt);
- bitmap_zero(ps->configured, cnt);
- bitmap_zero(ps->inuse, cnt);
- spin_unlock_irqrestore(&smp->state_lock, flags);
- }
- set_fifo_thresholds(smp, pipe, 0);
- }
- static void update_smp_state(struct mdp5_smp *smp,
- u32 cid, mdp5_smp_state_t *assigned)
- {
- struct mdp5_kms *mdp5_kms = get_kms(smp);
- int cnt = smp->blk_cnt;
- u32 blk, val;
- for_each_set_bit(blk, *assigned, cnt) {
- int idx = blk / 3;
- int fld = blk % 3;
- val = mdp5_read(mdp5_kms, REG_MDP5_MDP_SMP_ALLOC_W_REG(0, idx));
- switch (fld) {
- case 0:
- val &= ~MDP5_MDP_SMP_ALLOC_W_REG_CLIENT0__MASK;
- val |= MDP5_MDP_SMP_ALLOC_W_REG_CLIENT0(cid);
- break;
- case 1:
- val &= ~MDP5_MDP_SMP_ALLOC_W_REG_CLIENT1__MASK;
- val |= MDP5_MDP_SMP_ALLOC_W_REG_CLIENT1(cid);
- break;
- case 2:
- val &= ~MDP5_MDP_SMP_ALLOC_W_REG_CLIENT2__MASK;
- val |= MDP5_MDP_SMP_ALLOC_W_REG_CLIENT2(cid);
- break;
- }
- mdp5_write(mdp5_kms, REG_MDP5_MDP_SMP_ALLOC_W_REG(0, idx), val);
- mdp5_write(mdp5_kms, REG_MDP5_MDP_SMP_ALLOC_R_REG(0, idx), val);
- }
- }
- /* step #2: configure hw for union(pending, inuse): */
- void mdp5_smp_configure(struct mdp5_smp *smp, enum mdp5_pipe pipe)
- {
- int cnt = smp->blk_cnt;
- mdp5_smp_state_t assigned;
- int i;
- for (i = 0; i < pipe2nclients(pipe); i++) {
- u32 cid = pipe2client(pipe, i);
- struct mdp5_client_smp_state *ps = &smp->client_state[cid];
- /*
- * if vblank has not happened since last smp_configure
- * skip the configure for now
- */
- if (!bitmap_equal(ps->inuse, ps->configured, cnt))
- continue;
- bitmap_copy(ps->configured, ps->pending, cnt);
- bitmap_or(assigned, ps->inuse, ps->configured, cnt);
- update_smp_state(smp, cid, &assigned);
- }
- }
- /* step #3: after vblank, copy configured -> inuse: */
- void mdp5_smp_commit(struct mdp5_smp *smp, enum mdp5_pipe pipe)
- {
- int cnt = smp->blk_cnt;
- mdp5_smp_state_t released;
- int i;
- for (i = 0; i < pipe2nclients(pipe); i++) {
- u32 cid = pipe2client(pipe, i);
- struct mdp5_client_smp_state *ps = &smp->client_state[cid];
- /*
- * Figure out if there are any blocks we where previously
- * using, which can be released and made available to other
- * clients:
- */
- if (bitmap_andnot(released, ps->inuse, ps->configured, cnt)) {
- unsigned long flags;
- spin_lock_irqsave(&smp->state_lock, flags);
- /* clear released blocks: */
- bitmap_andnot(smp->state, smp->state, released, cnt);
- spin_unlock_irqrestore(&smp->state_lock, flags);
- update_smp_state(smp, CID_UNUSED, &released);
- }
- bitmap_copy(ps->inuse, ps->configured, cnt);
- }
- }
- void mdp5_smp_destroy(struct mdp5_smp *smp)
- {
- kfree(smp);
- }
- struct mdp5_smp *mdp5_smp_init(struct drm_device *dev, const struct mdp5_smp_block *cfg)
- {
- struct mdp5_smp *smp = NULL;
- int ret;
- smp = kzalloc(sizeof(*smp), GFP_KERNEL);
- if (unlikely(!smp)) {
- ret = -ENOMEM;
- goto fail;
- }
- smp->dev = dev;
- smp->blk_cnt = cfg->mmb_count;
- smp->blk_size = cfg->mmb_size;
- /* statically tied MMBs cannot be re-allocated: */
- bitmap_copy(smp->state, cfg->reserved_state, smp->blk_cnt);
- memcpy(smp->reserved, cfg->reserved, sizeof(smp->reserved));
- spin_lock_init(&smp->state_lock);
- return smp;
- fail:
- if (smp)
- mdp5_smp_destroy(smp);
- return ERR_PTR(ret);
- }
|