drivers/gpu/drm/msm/msm_gpu.c

   1 /*
   2  * Copyright (C) 2013 Red Hat
   3  * Author: Rob Clark <robdclark@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "msm_gpu.h"
  19 #include "msm_gem.h"
  20
  21
  22 /*
  23  * Power Management:
  24  */
  25
  26 #ifdef CONFIG_MSM_BUS_SCALING
  27 #include <mach/board.h>
  28 #include <mach/kgsl.h>
  29 static void bs_init(struct msm_gpu *gpu, struct platform_device *pdev)
  30 {
  31         struct drm_device *dev = gpu->dev;
  32         struct kgsl_device_platform_data *pdata = pdev->dev.platform_data;
  33
  34         if (!pdev) {
  35                 dev_err(dev->dev, "could not find dtv pdata\n");
  36                 return;
  37         }
  38
  39         if (pdata->bus_scale_table) {
  40                 gpu->bsc = msm_bus_scale_register_client(pdata->bus_scale_table);
  41                 DBG("bus scale client: %08x", gpu->bsc);
  42         }
  43 }
  44
  45 static void bs_fini(struct msm_gpu *gpu)
  46 {
  47         if (gpu->bsc) {
  48                 msm_bus_scale_unregister_client(gpu->bsc);
  49                 gpu->bsc = 0;
  50         }
  51 }
  52
  53 static void bs_set(struct msm_gpu *gpu, int idx)
  54 {
  55         if (gpu->bsc) {
  56                 DBG("set bus scaling: %d", idx);
  57                 msm_bus_scale_client_update_request(gpu->bsc, idx);
  58         }
  59 }
  60 #else
  61 static void bs_init(struct msm_gpu *gpu, struct platform_device *pdev) {}
  62 static void bs_fini(struct msm_gpu *gpu) {}
  63 static void bs_set(struct msm_gpu *gpu, int idx) {}
  64 #endif
  65
  66 static int enable_pwrrail(struct msm_gpu *gpu)
  67 {
  68         struct drm_device *dev = gpu->dev;
  69         int ret = 0;
  70
  71         if (gpu->gpu_reg) {
  72                 ret = regulator_enable(gpu->gpu_reg);
  73                 if (ret) {
  74                         dev_err(dev->dev, "failed to enable 'gpu_reg': %d\n", ret);
  75                         return ret;
  76                 }
  77         }
  78
  79         if (gpu->gpu_cx) {
  80                 ret = regulator_enable(gpu->gpu_cx);
  81                 if (ret) {
  82                         dev_err(dev->dev, "failed to enable 'gpu_cx': %d\n", ret);
  83                         return ret;
  84                 }
  85         }
  86
  87         return 0;
  88 }
  89
  90 static int disable_pwrrail(struct msm_gpu *gpu)
  91 {
  92         if (gpu->gpu_cx)
  93                 regulator_disable(gpu->gpu_cx);
  94         if (gpu->gpu_reg)
  95                 regulator_disable(gpu->gpu_reg);
  96         return 0;
  97 }
  98
  99 static int enable_clk(struct msm_gpu *gpu)
 100 {
 101         struct clk *rate_clk = NULL;
 102         int i;
 103
 104         /* NOTE: kgsl_pwrctrl_clk() ignores grp_clks[0].. */
 105         for (i = ARRAY_SIZE(gpu->grp_clks) - 1; i > 0; i--) {
 106                 if (gpu->grp_clks[i]) {
 107                         clk_prepare(gpu->grp_clks[i]);
 108                         rate_clk = gpu->grp_clks[i];
 109                 }
 110         }
 111
 112         if (rate_clk && gpu->fast_rate)
 113                 clk_set_rate(rate_clk, gpu->fast_rate);
 114
 115         for (i = ARRAY_SIZE(gpu->grp_clks) - 1; i > 0; i--)
 116                 if (gpu->grp_clks[i])
 117                         clk_enable(gpu->grp_clks[i]);
 118
 119         return 0;
 120 }
 121
 122 static int disable_clk(struct msm_gpu *gpu)
 123 {
 124         struct clk *rate_clk = NULL;
 125         int i;
 126
 127         /* NOTE: kgsl_pwrctrl_clk() ignores grp_clks[0].. */
 128         for (i = ARRAY_SIZE(gpu->grp_clks) - 1; i > 0; i--) {
 129                 if (gpu->grp_clks[i]) {
 130                         clk_disable(gpu->grp_clks[i]);
 131                         rate_clk = gpu->grp_clks[i];
 132                 }
 133         }
 134
 135         if (rate_clk && gpu->slow_rate)
 136                 clk_set_rate(rate_clk, gpu->slow_rate);
 137
 138         for (i = ARRAY_SIZE(gpu->grp_clks) - 1; i > 0; i--)
 139                 if (gpu->grp_clks[i])
 140                         clk_unprepare(gpu->grp_clks[i]);
 141
 142         return 0;
 143 }
 144
 145 static int enable_axi(struct msm_gpu *gpu)
 146 {
 147         if (gpu->ebi1_clk)
 148                 clk_prepare_enable(gpu->ebi1_clk);
 149         if (gpu->bus_freq)
 150                 bs_set(gpu, gpu->bus_freq);
 151         return 0;
 152 }
 153
 154 static int disable_axi(struct msm_gpu *gpu)
 155 {
 156         if (gpu->ebi1_clk)
 157                 clk_disable_unprepare(gpu->ebi1_clk);
 158         if (gpu->bus_freq)
 159                 bs_set(gpu, 0);
 160         return 0;
 161 }
 162
 163 int msm_gpu_pm_resume(struct msm_gpu *gpu)
 164 {
 165         int ret;
 166
 167         DBG("%s", gpu->name);
 168
 169         ret = enable_pwrrail(gpu);
 170         if (ret)
 171                 return ret;
 172
 173         ret = enable_clk(gpu);
 174         if (ret)
 175                 return ret;
 176
 177         ret = enable_axi(gpu);
 178         if (ret)
 179                 return ret;
 180
 181         return 0;
 182 }
 183
 184 int msm_gpu_pm_suspend(struct msm_gpu *gpu)
 185 {
 186         int ret;
 187
 188         DBG("%s", gpu->name);
 189
 190         ret = disable_axi(gpu);
 191         if (ret)
 192                 return ret;
 193
 194         ret = disable_clk(gpu);
 195         if (ret)
 196                 return ret;
 197
 198         ret = disable_pwrrail(gpu);
 199         if (ret)
 200                 return ret;
 201
 202         return 0;
 203 }
 204
 205 /*
 206  * Cmdstream submission/retirement:
 207  */
 208
 209 static void retire_worker(struct work_struct *work)
 210 {
 211         struct msm_gpu *gpu = container_of(work, struct msm_gpu, retire_work);
 212         struct drm_device *dev = gpu->dev;
 213         uint32_t fence = gpu->funcs->last_fence(gpu);
 214
 215         mutex_lock(&dev->struct_mutex);
 216
 217         while (!list_empty(&gpu->active_list)) {
 218                 struct msm_gem_object *obj;
 219
 220                 obj = list_first_entry(&gpu->active_list,
 221                                 struct msm_gem_object, mm_list);
 222
 223                 if (obj->fence <= fence) {
 224                         /* move to inactive: */
 225                         msm_gem_move_to_inactive(&obj->base);
 226                         msm_gem_put_iova(&obj->base, gpu->id);
 227                         drm_gem_object_unreference(&obj->base);
 228                 } else {
 229                         break;
 230                 }
 231         }
 232
 233         msm_update_fence(gpu->dev, fence);
 234
 235         mutex_unlock(&dev->struct_mutex);
 236 }
 237
 238 /* call from irq handler to schedule work to retire bo's */
 239 void msm_gpu_retire(struct msm_gpu *gpu)
 240 {
 241         struct msm_drm_private *priv = gpu->dev->dev_private;
 242         queue_work(priv->wq, &gpu->retire_work);
 243 }
 244
 245 /* add bo's to gpu's ring, and kick gpu: */
 246 int msm_gpu_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit,
 247                 struct msm_file_private *ctx)
 248 {
 249         struct drm_device *dev = gpu->dev;
 250         struct msm_drm_private *priv = dev->dev_private;
 251         int i, ret;
 252
 253         mutex_lock(&dev->struct_mutex);
 254
 255         submit->fence = ++priv->next_fence;
 256
 257         ret = gpu->funcs->submit(gpu, submit, ctx);
 258         priv->lastctx = ctx;
 259
 260         for (i = 0; i < submit->nr_bos; i++) {
 261                 struct msm_gem_object *msm_obj = submit->bos[i].obj;
 262
 263                 /* can't happen yet.. but when we add 2d support we'll have
 264                  * to deal w/ cross-ring synchronization:
 265                  */
 266                 WARN_ON(is_active(msm_obj) && (msm_obj->gpu != gpu));
 267
 268                 if (!is_active(msm_obj)) {
 269                         uint32_t iova;
 270
 271                         /* ring takes a reference to the bo and iova: */
 272                         drm_gem_object_reference(&msm_obj->base);
 273                         msm_gem_get_iova_locked(&msm_obj->base,
 274                                         submit->gpu->id, &iova);
 275                 }
 276
 277                 msm_gem_move_to_active(&msm_obj->base, gpu, submit->fence);
 278         }
 279         mutex_unlock(&dev->struct_mutex);
 280
 281         return ret;
 282 }
 283
 284 /*
 285  * Init/Cleanup:
 286  */
 287
 288 static irqreturn_t irq_handler(int irq, void *data)
 289 {
 290         struct msm_gpu *gpu = data;
 291         return gpu->funcs->irq(gpu);
 292 }
 293
 294 static const char *clk_names[] = {
 295                 "src_clk", "core_clk", "iface_clk", "mem_clk", "mem_iface_clk",
 296 };
 297
 298 int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev,
 299                 struct msm_gpu *gpu, const struct msm_gpu_funcs *funcs,
 300                 const char *name, const char *ioname, const char *irqname, int ringsz)
 301 {
 302         int i, ret;
 303
 304         gpu->dev = drm;
 305         gpu->funcs = funcs;
 306         gpu->name = name;
 307
 308         INIT_LIST_HEAD(&gpu->active_list);
 309         INIT_WORK(&gpu->retire_work, retire_worker);
 310
 311         BUG_ON(ARRAY_SIZE(clk_names) != ARRAY_SIZE(gpu->grp_clks));
 312
 313         /* Map registers: */
 314         gpu->mmio = msm_ioremap(pdev, ioname, name);
 315         if (IS_ERR(gpu->mmio)) {
 316                 ret = PTR_ERR(gpu->mmio);
 317                 goto fail;
 318         }
 319
 320         /* Get Interrupt: */
 321         gpu->irq = platform_get_irq_byname(pdev, irqname);
 322         if (gpu->irq < 0) {
 323                 ret = gpu->irq;
 324                 dev_err(drm->dev, "failed to get irq: %d\n", ret);
 325                 goto fail;
 326         }
 327
 328         ret = devm_request_irq(&pdev->dev, gpu->irq, irq_handler,
 329                         IRQF_TRIGGER_HIGH, gpu->name, gpu);
 330         if (ret) {
 331                 dev_err(drm->dev, "failed to request IRQ%u: %d\n", gpu->irq, ret);
 332                 goto fail;
 333         }
 334
 335         /* Acquire clocks: */
 336         for (i = 0; i < ARRAY_SIZE(clk_names); i++) {
 337                 gpu->grp_clks[i] = devm_clk_get(&pdev->dev, clk_names[i]);
 338                 DBG("grp_clks[%s]: %p", clk_names[i], gpu->grp_clks[i]);
 339                 if (IS_ERR(gpu->grp_clks[i]))
 340                         gpu->grp_clks[i] = NULL;
 341         }
 342
 343         gpu->ebi1_clk = devm_clk_get(&pdev->dev, "bus_clk");
 344         DBG("ebi1_clk: %p", gpu->ebi1_clk);
 345         if (IS_ERR(gpu->ebi1_clk))
 346                 gpu->ebi1_clk = NULL;
 347
 348         /* Acquire regulators: */
 349         gpu->gpu_reg = devm_regulator_get(&pdev->dev, "vdd");
 350         DBG("gpu_reg: %p", gpu->gpu_reg);
 351         if (IS_ERR(gpu->gpu_reg))
 352                 gpu->gpu_reg = NULL;
 353
 354         gpu->gpu_cx = devm_regulator_get(&pdev->dev, "vddcx");
 355         DBG("gpu_cx: %p", gpu->gpu_cx);
 356         if (IS_ERR(gpu->gpu_cx))
 357                 gpu->gpu_cx = NULL;
 358
 359         /* Setup IOMMU.. eventually we will (I think) do this once per context
 360          * and have separate page tables per context.  For now, to keep things
 361          * simple and to get something working, just use a single address space:
 362          */
 363         gpu->iommu = iommu_domain_alloc(&platform_bus_type);
 364         if (!gpu->iommu) {
 365                 dev_err(drm->dev, "failed to allocate IOMMU\n");
 366                 ret = -ENOMEM;
 367                 goto fail;
 368         }
 369         gpu->id = msm_register_iommu(drm, gpu->iommu);
 370
 371         /* Create ringbuffer: */
 372         gpu->rb = msm_ringbuffer_new(gpu, ringsz);
 373         if (IS_ERR(gpu->rb)) {
 374                 ret = PTR_ERR(gpu->rb);
 375                 gpu->rb = NULL;
 376                 dev_err(drm->dev, "could not create ringbuffer: %d\n", ret);
 377                 goto fail;
 378         }
 379
 380         ret = msm_gem_get_iova_locked(gpu->rb->bo, gpu->id, &gpu->rb_iova);
 381         if (ret) {
 382                 gpu->rb_iova = 0;
 383                 dev_err(drm->dev, "could not map ringbuffer: %d\n", ret);
 384                 goto fail;
 385         }
 386
 387         bs_init(gpu, pdev);
 388
 389         return 0;
 390
 391 fail:
 392         return ret;
 393 }
 394
 395 void msm_gpu_cleanup(struct msm_gpu *gpu)
 396 {
 397         DBG("%s", gpu->name);
 398
 399         WARN_ON(!list_empty(&gpu->active_list));
 400
 401         bs_fini(gpu);
 402
 403         if (gpu->rb) {
 404                 if (gpu->rb_iova)
 405                         msm_gem_put_iova(gpu->rb->bo, gpu->id);
 406                 msm_ringbuffer_destroy(gpu->rb);
 407         }
 408
 409         if (gpu->iommu)
 410                 iommu_domain_free(gpu->iommu);
 411 }