LXR linux/drivers/gpu/host1x/hw/channel

   1/*
   2 * Tegra host1x Channel
   3 *
   4 * Copyright (c) 2010-2013, NVIDIA Corporation.
   5 *
   6 * This program is free software; you can redistribute it and/or modify it
   7 * under the terms and conditions of the GNU General Public License,
   8 * version 2, as published by the Free Software Foundation.
   9 *
  10 * This program is distributed in the hope 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
  16 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19#include <linux/slab.h>
  20#include <trace/events/host1x.h>
  21
  22#include "host1x.h"
  23#include "host1x_bo.h"
  24#include "channel.h"
  25#include "dev.h"
  26#include "intr.h"
  27#include "job.h"
  28
  29#define HOST1X_CHANNEL_SIZE 16384
  30#define TRACE_MAX_LENGTH 128U
  31
  32static void trace_write_gather(struct host1x_cdma *cdma, struct host1x_bo *bo,
  33                               u32 offset, u32 words)
  34{
  35        void *mem = NULL;
  36
  37        if (host1x_debug_trace_cmdbuf)
  38                mem = host1x_bo_mmap(bo);
  39
  40        if (mem) {
  41                u32 i;
  42                /*
  43                 * Write in batches of 128 as there seems to be a limit
  44                 * of how much you can output to ftrace at once.
  45                 */
  46                for (i = 0; i < words; i += TRACE_MAX_LENGTH) {
  47                        trace_host1x_cdma_push_gather(
  48                                dev_name(cdma_to_channel(cdma)->dev),
  49                                (u32)bo, min(words - i, TRACE_MAX_LENGTH),
  50                                offset + i * sizeof(u32), mem);
  51                }
  52                host1x_bo_munmap(bo, mem);
  53        }
  54}
  55
  56static void submit_gathers(struct host1x_job *job)
  57{
  58        struct host1x_cdma *cdma = &job->channel->cdma;
  59        unsigned int i;
  60
  61        for (i = 0; i < job->num_gathers; i++) {
  62                struct host1x_job_gather *g = &job->gathers[i];
  63                u32 op1 = host1x_opcode_gather(g->words);
  64                u32 op2 = g->base + g->offset;
  65                trace_write_gather(cdma, g->bo, g->offset, op1 & 0xffff);
  66                host1x_cdma_push(cdma, op1, op2);
  67        }
  68}
  69
  70static int channel_submit(struct host1x_job *job)
  71{
  72        struct host1x_channel *ch = job->channel;
  73        struct host1x_syncpt *sp;
  74        u32 user_syncpt_incrs = job->syncpt_incrs;
  75        u32 prev_max = 0;
  76        u32 syncval;
  77        int err;
  78        struct host1x_waitlist *completed_waiter = NULL;
  79        struct host1x *host = dev_get_drvdata(ch->dev->parent);
  80
  81        sp = host->syncpt + job->syncpt_id;
  82        trace_host1x_channel_submit(dev_name(ch->dev),
  83                                    job->num_gathers, job->num_relocs,
  84                                    job->num_waitchk, job->syncpt_id,
  85                                    job->syncpt_incrs);
  86
  87        /* before error checks, return current max */
  88        prev_max = job->syncpt_end = host1x_syncpt_read_max(sp);
  89
  90        /* get submit lock */
  91        err = mutex_lock_interruptible(&ch->submitlock);
  92        if (err)
  93                goto error;
  94
  95        completed_waiter = kzalloc(sizeof(*completed_waiter), GFP_KERNEL);
  96        if (!completed_waiter) {
  97                mutex_unlock(&ch->submitlock);
  98                err = -ENOMEM;
  99                goto error;
 100        }
 101
 102        /* begin a CDMA submit */
 103        err = host1x_cdma_begin(&ch->cdma, job);
 104        if (err) {
 105                mutex_unlock(&ch->submitlock);
 106                goto error;
 107        }
 108
 109        if (job->serialize) {
 110                /*
 111                 * Force serialization by inserting a host wait for the
 112                 * previous job to finish before this one can commence.
 113                 */
 114                host1x_cdma_push(&ch->cdma,
 115                                 host1x_opcode_setclass(HOST1X_CLASS_HOST1X,
 116                                        host1x_uclass_wait_syncpt_r(), 1),
 117                                 host1x_class_host_wait_syncpt(job->syncpt_id,
 118                                        host1x_syncpt_read_max(sp)));
 119        }
 120
 121        syncval = host1x_syncpt_incr_max(sp, user_syncpt_incrs);
 122
 123        job->syncpt_end = syncval;
 124
 125        /* add a setclass for modules that require it */
 126        if (job->class)
 127                host1x_cdma_push(&ch->cdma,
 128                                 host1x_opcode_setclass(job->class, 0, 0),
 129                                 HOST1X_OPCODE_NOP);
 130
 131        submit_gathers(job);
 132
 133        /* end CDMA submit & stash pinned hMems into sync queue */
 134        host1x_cdma_end(&ch->cdma, job);
 135
 136        trace_host1x_channel_submitted(dev_name(ch->dev), prev_max, syncval);
 137
 138        /* schedule a submit complete interrupt */
 139        err = host1x_intr_add_action(host, job->syncpt_id, syncval,
 140                                     HOST1X_INTR_ACTION_SUBMIT_COMPLETE, ch,
 141                                     completed_waiter, NULL);
 142        completed_waiter = NULL;
 143        WARN(err, "Failed to set submit complete interrupt");
 144
 145        mutex_unlock(&ch->submitlock);
 146
 147        return 0;
 148
 149error:
 150        kfree(completed_waiter);
 151        return err;
 152}
 153
 154static int host1x_channel_init(struct host1x_channel *ch, struct host1x *dev,
 155                               unsigned int index)
 156{
 157        ch->id = index;
 158        mutex_init(&ch->reflock);
 159        mutex_init(&ch->submitlock);
 160
 161        ch->regs = dev->regs + index * HOST1X_CHANNEL_SIZE;
 162        return 0;
 163}
 164
 165static const struct host1x_channel_ops host1x_channel_ops = {
 166        .init = host1x_channel_init,
 167        .submit = channel_submit,
 168};
 169