drivers/gpu/drm/tegra/gr2d.c

   1 /*
   2  * Copyright (c) 2012-2013, NVIDIA Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include <linux/clk.h>
  18
  19 #include "drm.h"
  20 #include "gem.h"
  21 #include "gr2d.h"
  22
  23 struct gr2d {
  24         struct tegra_drm_client client;
  25         struct host1x_channel *channel;
  26         struct clk *clk;
  27
  28         DECLARE_BITMAP(addr_regs, GR2D_NUM_REGS);
  29 };
  30
  31 static inline struct gr2d *to_gr2d(struct tegra_drm_client *client)
  32 {
  33         return container_of(client, struct gr2d, client);
  34 }
  35
  36 static int gr2d_init(struct host1x_client *client)
  37 {
  38         struct tegra_drm_client *drm = host1x_to_drm_client(client);
  39         struct tegra_drm *tegra = dev_get_drvdata(client->parent);
  40         struct gr2d *gr2d = to_gr2d(drm);
  41
  42         gr2d->channel = host1x_channel_request(client->dev);
  43         if (!gr2d->channel)
  44                 return -ENOMEM;
  45
  46         client->syncpts[0] = host1x_syncpt_request(client->dev, false);
  47         if (!client->syncpts[0]) {
  48                 host1x_channel_free(gr2d->channel);
  49                 return -ENOMEM;
  50         }
  51
  52         return tegra_drm_register_client(tegra, drm);
  53 }
  54
  55 static int gr2d_exit(struct host1x_client *client)
  56 {
  57         struct tegra_drm_client *drm = host1x_to_drm_client(client);
  58         struct tegra_drm *tegra = dev_get_drvdata(client->parent);
  59         struct gr2d *gr2d = to_gr2d(drm);
  60         int err;
  61
  62         err = tegra_drm_unregister_client(tegra, drm);
  63         if (err < 0)
  64                 return err;
  65
  66         host1x_syncpt_free(client->syncpts[0]);
  67         host1x_channel_free(gr2d->channel);
  68
  69         return 0;
  70 }
  71
  72 static const struct host1x_client_ops gr2d_client_ops = {
  73         .init = gr2d_init,
  74         .exit = gr2d_exit,
  75 };
  76
  77 static int gr2d_open_channel(struct tegra_drm_client *client,
  78                              struct tegra_drm_context *context)
  79 {
  80         struct gr2d *gr2d = to_gr2d(client);
  81
  82         context->channel = host1x_channel_get(gr2d->channel);
  83         if (!context->channel)
  84                 return -ENOMEM;
  85
  86         return 0;
  87 }
  88
  89 static void gr2d_close_channel(struct tegra_drm_context *context)
  90 {
  91         host1x_channel_put(context->channel);
  92 }
  93
  94 static struct host1x_bo *host1x_bo_lookup(struct drm_device *drm,
  95                                           struct drm_file *file,
  96                                           u32 handle)
  97 {
  98         struct drm_gem_object *gem;
  99         struct tegra_bo *bo;
 100
 101         gem = drm_gem_object_lookup(drm, file, handle);
 102         if (!gem)
 103                 return NULL;
 104
 105         mutex_lock(&drm->struct_mutex);
 106         drm_gem_object_unreference(gem);
 107         mutex_unlock(&drm->struct_mutex);
 108
 109         bo = to_tegra_bo(gem);
 110         return &bo->base;
 111 }
 112
 113 static int gr2d_is_addr_reg(struct device *dev, u32 class, u32 offset)
 114 {
 115         struct gr2d *gr2d = dev_get_drvdata(dev);
 116
 117         switch (class) {
 118         case HOST1X_CLASS_HOST1X:
 119                 if (offset == 0x2b)
 120                         return 1;
 121
 122                 break;
 123
 124         case HOST1X_CLASS_GR2D:
 125         case HOST1X_CLASS_GR2D_SB:
 126                 if (offset >= GR2D_NUM_REGS)
 127                         break;
 128
 129                 if (test_bit(offset, gr2d->addr_regs))
 130                         return 1;
 131
 132                 break;
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int gr2d_submit(struct tegra_drm_context *context,
 139                        struct drm_tegra_submit *args, struct drm_device *drm,
 140                        struct drm_file *file)
 141 {
 142         unsigned int num_cmdbufs = args->num_cmdbufs;
 143         unsigned int num_relocs = args->num_relocs;
 144         unsigned int num_waitchks = args->num_waitchks;
 145         struct drm_tegra_cmdbuf __user *cmdbufs =
 146                 (void * __user)(uintptr_t)args->cmdbufs;
 147         struct drm_tegra_reloc __user *relocs =
 148                 (void * __user)(uintptr_t)args->relocs;
 149         struct drm_tegra_waitchk __user *waitchks =
 150                 (void * __user)(uintptr_t)args->waitchks;
 151         struct drm_tegra_syncpt syncpt;
 152         struct host1x_job *job;
 153         int err;
 154
 155         /* We don't yet support other than one syncpt_incr struct per submit */
 156         if (args->num_syncpts != 1)
 157                 return -EINVAL;
 158
 159         job = host1x_job_alloc(context->channel, args->num_cmdbufs,
 160                                args->num_relocs, args->num_waitchks);
 161         if (!job)
 162                 return -ENOMEM;
 163
 164         job->num_relocs = args->num_relocs;
 165         job->num_waitchk = args->num_waitchks;
 166         job->client = (u32)args->context;
 167         job->class = context->client->base.class;
 168         job->serialize = true;
 169
 170         while (num_cmdbufs) {
 171                 struct drm_tegra_cmdbuf cmdbuf;
 172                 struct host1x_bo *bo;
 173
 174                 err = copy_from_user(&cmdbuf, cmdbufs, sizeof(cmdbuf));
 175                 if (err)
 176                         goto fail;
 177
 178                 bo = host1x_bo_lookup(drm, file, cmdbuf.handle);
 179                 if (!bo) {
 180                         err = -ENOENT;
 181                         goto fail;
 182                 }
 183
 184                 host1x_job_add_gather(job, bo, cmdbuf.words, cmdbuf.offset);
 185                 num_cmdbufs--;
 186                 cmdbufs++;
 187         }
 188
 189         err = copy_from_user(job->relocarray, relocs,
 190                              sizeof(*relocs) * num_relocs);
 191         if (err)
 192                 goto fail;
 193
 194         while (num_relocs--) {
 195                 struct host1x_reloc *reloc = &job->relocarray[num_relocs];
 196                 struct host1x_bo *cmdbuf, *target;
 197
 198                 cmdbuf = host1x_bo_lookup(drm, file, (u32)reloc->cmdbuf);
 199                 target = host1x_bo_lookup(drm, file, (u32)reloc->target);
 200
 201                 reloc->cmdbuf = cmdbuf;
 202                 reloc->target = target;
 203
 204                 if (!reloc->target || !reloc->cmdbuf) {
 205                         err = -ENOENT;
 206                         goto fail;
 207                 }
 208         }
 209
 210         err = copy_from_user(job->waitchk, waitchks,
 211                              sizeof(*waitchks) * num_waitchks);
 212         if (err)
 213                 goto fail;
 214
 215         err = copy_from_user(&syncpt, (void * __user)(uintptr_t)args->syncpts,
 216                              sizeof(syncpt));
 217         if (err)
 218                 goto fail;
 219
 220         job->syncpt_id = syncpt.id;
 221         job->syncpt_incrs = syncpt.incrs;
 222         job->timeout = 10000;
 223         job->is_addr_reg = gr2d_is_addr_reg;
 224
 225         if (args->timeout && args->timeout < 10000)
 226                 job->timeout = args->timeout;
 227
 228         err = host1x_job_pin(job, context->client->base.dev);
 229         if (err)
 230                 goto fail;
 231
 232         err = host1x_job_submit(job);
 233         if (err)
 234                 goto fail_submit;
 235
 236         args->fence = job->syncpt_end;
 237
 238         host1x_job_put(job);
 239         return 0;
 240
 241 fail_submit:
 242         host1x_job_unpin(job);
 243 fail:
 244         host1x_job_put(job);
 245         return err;
 246 }
 247
 248 static const struct tegra_drm_client_ops gr2d_ops = {
 249         .open_channel = gr2d_open_channel,
 250         .close_channel = gr2d_close_channel,
 251         .submit = gr2d_submit,
 252 };
 253
 254 static const struct of_device_id gr2d_match[] = {
 255         { .compatible = "nvidia,tegra30-gr2d" },
 256         { .compatible = "nvidia,tegra20-gr2d" },
 257         { },
 258 };
 259
 260 static const u32 gr2d_addr_regs[] = {
 261         GR2D_UA_BASE_ADDR,
 262         GR2D_VA_BASE_ADDR,
 263         GR2D_PAT_BASE_ADDR,
 264         GR2D_DSTA_BASE_ADDR,
 265         GR2D_DSTB_BASE_ADDR,
 266         GR2D_DSTC_BASE_ADDR,
 267         GR2D_SRCA_BASE_ADDR,
 268         GR2D_SRCB_BASE_ADDR,
 269         GR2D_SRC_BASE_ADDR_SB,
 270         GR2D_DSTA_BASE_ADDR_SB,
 271         GR2D_DSTB_BASE_ADDR_SB,
 272         GR2D_UA_BASE_ADDR_SB,
 273         GR2D_VA_BASE_ADDR_SB,
 274 };
 275
 276 static int gr2d_probe(struct platform_device *pdev)
 277 {
 278         struct device *dev = &pdev->dev;
 279         struct host1x_syncpt **syncpts;
 280         struct gr2d *gr2d;
 281         unsigned int i;
 282         int err;
 283
 284         gr2d = devm_kzalloc(dev, sizeof(*gr2d), GFP_KERNEL);
 285         if (!gr2d)
 286                 return -ENOMEM;
 287
 288         syncpts = devm_kzalloc(dev, sizeof(*syncpts), GFP_KERNEL);
 289         if (!syncpts)
 290                 return -ENOMEM;
 291
 292         gr2d->clk = devm_clk_get(dev, NULL);
 293         if (IS_ERR(gr2d->clk)) {
 294                 dev_err(dev, "cannot get clock\n");
 295                 return PTR_ERR(gr2d->clk);
 296         }
 297
 298         err = clk_prepare_enable(gr2d->clk);
 299         if (err) {
 300                 dev_err(dev, "cannot turn on clock\n");
 301                 return err;
 302         }
 303
 304         INIT_LIST_HEAD(&gr2d->client.base.list);
 305         gr2d->client.base.ops = &gr2d_client_ops;
 306         gr2d->client.base.dev = dev;
 307         gr2d->client.base.class = HOST1X_CLASS_GR2D;
 308         gr2d->client.base.syncpts = syncpts;
 309         gr2d->client.base.num_syncpts = 1;
 310
 311         INIT_LIST_HEAD(&gr2d->client.list);
 312         gr2d->client.ops = &gr2d_ops;
 313
 314         err = host1x_client_register(&gr2d->client.base);
 315         if (err < 0) {
 316                 dev_err(dev, "failed to register host1x client: %d\n", err);
 317                 return err;
 318         }
 319
 320         /* initialize address register map */
 321         for (i = 0; i < ARRAY_SIZE(gr2d_addr_regs); i++)
 322                 set_bit(gr2d_addr_regs[i], gr2d->addr_regs);
 323
 324         platform_set_drvdata(pdev, gr2d);
 325
 326         return 0;
 327 }
 328
 329 static int gr2d_remove(struct platform_device *pdev)
 330 {
 331         struct gr2d *gr2d = platform_get_drvdata(pdev);
 332         int err;
 333
 334         err = host1x_client_unregister(&gr2d->client.base);
 335         if (err < 0) {
 336                 dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
 337                         err);
 338                 return err;
 339         }
 340
 341         clk_disable_unprepare(gr2d->clk);
 342
 343         return 0;
 344 }
 345
 346 struct platform_driver tegra_gr2d_driver = {
 347         .driver = {
 348                 .name = "tegra-gr2d",
 349                 .of_match_table = gr2d_match,
 350         },
 351         .probe = gr2d_probe,
 352         .remove = gr2d_remove,
 353 };