drivers/gpu/ipu-v3/ipu-dmfc.c

   1 /*
   2  * Copyright (c) 2010 Sascha Hauer <s.hauer@pengutronix.de>
   3  * Copyright (C) 2005-2009 Freescale Semiconductor, Inc.
   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 as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15 #include <linux/export.h>
  16 #include <linux/types.h>
  17 #include <linux/errno.h>
  18 #include <linux/io.h>
  19
  20 #include <video/imx-ipu-v3.h>
  21 #include "ipu-prv.h"
  22
  23 #define DMFC_RD_CHAN            0x0000
  24 #define DMFC_WR_CHAN            0x0004
  25 #define DMFC_WR_CHAN_DEF        0x0008
  26 #define DMFC_DP_CHAN            0x000c
  27 #define DMFC_DP_CHAN_DEF        0x0010
  28 #define DMFC_GENERAL1           0x0014
  29 #define DMFC_GENERAL2           0x0018
  30 #define DMFC_IC_CTRL            0x001c
  31 #define DMFC_WR_CHAN_ALT        0x0020
  32 #define DMFC_WR_CHAN_DEF_ALT    0x0024
  33 #define DMFC_DP_CHAN_ALT        0x0028
  34 #define DMFC_DP_CHAN_DEF_ALT    0x002c
  35 #define DMFC_GENERAL1_ALT       0x0030
  36 #define DMFC_STAT               0x0034
  37
  38 #define DMFC_WR_CHAN_1_28               0
  39 #define DMFC_WR_CHAN_2_41               8
  40 #define DMFC_WR_CHAN_1C_42              16
  41 #define DMFC_WR_CHAN_2C_43              24
  42
  43 #define DMFC_DP_CHAN_5B_23              0
  44 #define DMFC_DP_CHAN_5F_27              8
  45 #define DMFC_DP_CHAN_6B_24              16
  46 #define DMFC_DP_CHAN_6F_29              24
  47
  48 #define DMFC_FIFO_SIZE_64               (3 << 3)
  49 #define DMFC_FIFO_SIZE_128              (2 << 3)
  50 #define DMFC_FIFO_SIZE_256              (1 << 3)
  51 #define DMFC_FIFO_SIZE_512              (0 << 3)
  52
  53 #define DMFC_SEGMENT(x)                 ((x & 0x7) << 0)
  54 #define DMFC_BURSTSIZE_128              (0 << 6)
  55 #define DMFC_BURSTSIZE_64               (1 << 6)
  56 #define DMFC_BURSTSIZE_32               (2 << 6)
  57 #define DMFC_BURSTSIZE_16               (3 << 6)
  58
  59 struct dmfc_channel_data {
  60         int             ipu_channel;
  61         unsigned long   channel_reg;
  62         unsigned long   shift;
  63         unsigned        eot_shift;
  64         unsigned        max_fifo_lines;
  65 };
  66
  67 static const struct dmfc_channel_data dmfcdata[] = {
  68         {
  69                 .ipu_channel    = IPUV3_CHANNEL_MEM_BG_SYNC,
  70                 .channel_reg    = DMFC_DP_CHAN,
  71                 .shift          = DMFC_DP_CHAN_5B_23,
  72                 .eot_shift      = 20,
  73                 .max_fifo_lines = 3,
  74         }, {
  75                 .ipu_channel    = 24,
  76                 .channel_reg    = DMFC_DP_CHAN,
  77                 .shift          = DMFC_DP_CHAN_6B_24,
  78                 .eot_shift      = 22,
  79                 .max_fifo_lines = 1,
  80         }, {
  81                 .ipu_channel    = IPUV3_CHANNEL_MEM_FG_SYNC,
  82                 .channel_reg    = DMFC_DP_CHAN,
  83                 .shift          = DMFC_DP_CHAN_5F_27,
  84                 .eot_shift      = 21,
  85                 .max_fifo_lines = 2,
  86         }, {
  87                 .ipu_channel    = IPUV3_CHANNEL_MEM_DC_SYNC,
  88                 .channel_reg    = DMFC_WR_CHAN,
  89                 .shift          = DMFC_WR_CHAN_1_28,
  90                 .eot_shift      = 16,
  91                 .max_fifo_lines = 2,
  92         }, {
  93                 .ipu_channel    = 29,
  94                 .channel_reg    = DMFC_DP_CHAN,
  95                 .shift          = DMFC_DP_CHAN_6F_29,
  96                 .eot_shift      = 23,
  97                 .max_fifo_lines = 1,
  98         },
  99 };
 100
 101 #define DMFC_NUM_CHANNELS       ARRAY_SIZE(dmfcdata)
 102
 103 struct ipu_dmfc_priv;
 104
 105 struct dmfc_channel {
 106         unsigned                        slots;
 107         unsigned                        slotmask;
 108         unsigned                        segment;
 109         int                             burstsize;
 110         struct ipu_soc                  *ipu;
 111         struct ipu_dmfc_priv            *priv;
 112         const struct dmfc_channel_data  *data;
 113 };
 114
 115 struct ipu_dmfc_priv {
 116         struct ipu_soc *ipu;
 117         struct device *dev;
 118         struct dmfc_channel channels[DMFC_NUM_CHANNELS];
 119         struct mutex mutex;
 120         unsigned long bandwidth_per_slot;
 121         void __iomem *base;
 122         int use_count;
 123 };
 124
 125 int ipu_dmfc_enable_channel(struct dmfc_channel *dmfc)
 126 {
 127         struct ipu_dmfc_priv *priv = dmfc->priv;
 128         mutex_lock(&priv->mutex);
 129
 130         if (!priv->use_count)
 131                 ipu_module_enable(priv->ipu, IPU_CONF_DMFC_EN);
 132
 133         priv->use_count++;
 134
 135         mutex_unlock(&priv->mutex);
 136
 137         return 0;
 138 }
 139 EXPORT_SYMBOL_GPL(ipu_dmfc_enable_channel);
 140
 141 static void ipu_dmfc_wait_fifos(struct ipu_dmfc_priv *priv)
 142 {
 143         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
 144
 145         while ((readl(priv->base + DMFC_STAT) & 0x02fff000) != 0x02fff000) {
 146                 if (time_after(jiffies, timeout)) {
 147                         dev_warn(priv->dev,
 148                                  "Timeout waiting for DMFC FIFOs to clear\n");
 149                         break;
 150                 }
 151                 cpu_relax();
 152         }
 153 }
 154
 155 void ipu_dmfc_disable_channel(struct dmfc_channel *dmfc)
 156 {
 157         struct ipu_dmfc_priv *priv = dmfc->priv;
 158
 159         mutex_lock(&priv->mutex);
 160
 161         priv->use_count--;
 162
 163         if (!priv->use_count) {
 164                 ipu_dmfc_wait_fifos(priv);
 165                 ipu_module_disable(priv->ipu, IPU_CONF_DMFC_EN);
 166         }
 167
 168         if (priv->use_count < 0)
 169                 priv->use_count = 0;
 170
 171         mutex_unlock(&priv->mutex);
 172 }
 173 EXPORT_SYMBOL_GPL(ipu_dmfc_disable_channel);
 174
 175 static int ipu_dmfc_setup_channel(struct dmfc_channel *dmfc, int slots,
 176                 int segment, int burstsize)
 177 {
 178         struct ipu_dmfc_priv *priv = dmfc->priv;
 179         u32 val, field;
 180
 181         dev_dbg(priv->dev,
 182                         "dmfc: using %d slots starting from segment %d for IPU channel %d\n",
 183                         slots, segment, dmfc->data->ipu_channel);
 184
 185         switch (slots) {
 186         case 1:
 187                 field = DMFC_FIFO_SIZE_64;
 188                 break;
 189         case 2:
 190                 field = DMFC_FIFO_SIZE_128;
 191                 break;
 192         case 4:
 193                 field = DMFC_FIFO_SIZE_256;
 194                 break;
 195         case 8:
 196                 field = DMFC_FIFO_SIZE_512;
 197                 break;
 198         default:
 199                 return -EINVAL;
 200         }
 201
 202         switch (burstsize) {
 203         case 16:
 204                 field |= DMFC_BURSTSIZE_16;
 205                 break;
 206         case 32:
 207                 field |= DMFC_BURSTSIZE_32;
 208                 break;
 209         case 64:
 210                 field |= DMFC_BURSTSIZE_64;
 211                 break;
 212         case 128:
 213                 field |= DMFC_BURSTSIZE_128;
 214                 break;
 215         }
 216
 217         field |= DMFC_SEGMENT(segment);
 218
 219         val = readl(priv->base + dmfc->data->channel_reg);
 220
 221         val &= ~(0xff << dmfc->data->shift);
 222         val |= field << dmfc->data->shift;
 223
 224         writel(val, priv->base + dmfc->data->channel_reg);
 225
 226         dmfc->slots = slots;
 227         dmfc->segment = segment;
 228         dmfc->burstsize = burstsize;
 229         dmfc->slotmask = ((1 << slots) - 1) << segment;
 230
 231         return 0;
 232 }
 233
 234 static int dmfc_bandwidth_to_slots(struct ipu_dmfc_priv *priv,
 235                 unsigned long bandwidth)
 236 {
 237         int slots = 1;
 238
 239         while (slots * priv->bandwidth_per_slot < bandwidth)
 240                 slots *= 2;
 241
 242         return slots;
 243 }
 244
 245 static int dmfc_find_slots(struct ipu_dmfc_priv *priv, int slots)
 246 {
 247         unsigned slotmask_need, slotmask_used = 0;
 248         int i, segment = 0;
 249
 250         slotmask_need = (1 << slots) - 1;
 251
 252         for (i = 0; i < DMFC_NUM_CHANNELS; i++)
 253                 slotmask_used |= priv->channels[i].slotmask;
 254
 255         while (slotmask_need <= 0xff) {
 256                 if (!(slotmask_used & slotmask_need))
 257                         return segment;
 258
 259                 slotmask_need <<= 1;
 260                 segment++;
 261         }
 262
 263         return -EBUSY;
 264 }
 265
 266 void ipu_dmfc_free_bandwidth(struct dmfc_channel *dmfc)
 267 {
 268         struct ipu_dmfc_priv *priv = dmfc->priv;
 269         int i;
 270
 271         dev_dbg(priv->dev, "dmfc: freeing %d slots starting from segment %d\n",
 272                         dmfc->slots, dmfc->segment);
 273
 274         mutex_lock(&priv->mutex);
 275
 276         if (!dmfc->slots)
 277                 goto out;
 278
 279         dmfc->slotmask = 0;
 280         dmfc->slots = 0;
 281         dmfc->segment = 0;
 282
 283         for (i = 0; i < DMFC_NUM_CHANNELS; i++)
 284                 priv->channels[i].slotmask = 0;
 285
 286         for (i = 0; i < DMFC_NUM_CHANNELS; i++) {
 287                 if (priv->channels[i].slots > 0) {
 288                         priv->channels[i].segment =
 289                                 dmfc_find_slots(priv, priv->channels[i].slots);
 290                         priv->channels[i].slotmask =
 291                                 ((1 << priv->channels[i].slots) - 1) <<
 292                                 priv->channels[i].segment;
 293                 }
 294         }
 295
 296         for (i = 0; i < DMFC_NUM_CHANNELS; i++) {
 297                 if (priv->channels[i].slots > 0)
 298                         ipu_dmfc_setup_channel(&priv->channels[i],
 299                                         priv->channels[i].slots,
 300                                         priv->channels[i].segment,
 301                                         priv->channels[i].burstsize);
 302         }
 303 out:
 304         mutex_unlock(&priv->mutex);
 305 }
 306 EXPORT_SYMBOL_GPL(ipu_dmfc_free_bandwidth);
 307
 308 int ipu_dmfc_alloc_bandwidth(struct dmfc_channel *dmfc,
 309                 unsigned long bandwidth_pixel_per_second, int burstsize)
 310 {
 311         struct ipu_dmfc_priv *priv = dmfc->priv;
 312         int slots = dmfc_bandwidth_to_slots(priv, bandwidth_pixel_per_second);
 313         int segment = -1, ret = 0;
 314
 315         dev_dbg(priv->dev, "dmfc: trying to allocate %ldMpixel/s for IPU channel %d\n",
 316                         bandwidth_pixel_per_second / 1000000,
 317                         dmfc->data->ipu_channel);
 318
 319         ipu_dmfc_free_bandwidth(dmfc);
 320
 321         mutex_lock(&priv->mutex);
 322
 323         if (slots > 8) {
 324                 ret = -EBUSY;
 325                 goto out;
 326         }
 327
 328         /* For the MEM_BG channel, first try to allocate twice the slots */
 329         if (dmfc->data->ipu_channel == IPUV3_CHANNEL_MEM_BG_SYNC)
 330                 segment = dmfc_find_slots(priv, slots * 2);
 331         else if (slots < 2)
 332                 /* Always allocate at least 128*4 bytes (2 slots) */
 333                 slots = 2;
 334
 335         if (segment >= 0)
 336                 slots *= 2;
 337         else
 338                 segment = dmfc_find_slots(priv, slots);
 339         if (segment < 0) {
 340                 ret = -EBUSY;
 341                 goto out;
 342         }
 343
 344         ipu_dmfc_setup_channel(dmfc, slots, segment, burstsize);
 345
 346 out:
 347         mutex_unlock(&priv->mutex);
 348
 349         return ret;
 350 }
 351 EXPORT_SYMBOL_GPL(ipu_dmfc_alloc_bandwidth);
 352
 353 void ipu_dmfc_config_wait4eot(struct dmfc_channel *dmfc, int width)
 354 {
 355         struct ipu_dmfc_priv *priv = dmfc->priv;
 356         u32 dmfc_gen1;
 357
 358         mutex_lock(&priv->mutex);
 359
 360         dmfc_gen1 = readl(priv->base + DMFC_GENERAL1);
 361
 362         if ((dmfc->slots * 64 * 4) / width > dmfc->data->max_fifo_lines)
 363                 dmfc_gen1 |= 1 << dmfc->data->eot_shift;
 364         else
 365                 dmfc_gen1 &= ~(1 << dmfc->data->eot_shift);
 366
 367         writel(dmfc_gen1, priv->base + DMFC_GENERAL1);
 368
 369         mutex_unlock(&priv->mutex);
 370 }
 371 EXPORT_SYMBOL_GPL(ipu_dmfc_config_wait4eot);
 372
 373 struct dmfc_channel *ipu_dmfc_get(struct ipu_soc *ipu, int ipu_channel)
 374 {
 375         struct ipu_dmfc_priv *priv = ipu->dmfc_priv;
 376         int i;
 377
 378         for (i = 0; i < DMFC_NUM_CHANNELS; i++)
 379                 if (dmfcdata[i].ipu_channel == ipu_channel)
 380                         return &priv->channels[i];
 381         return ERR_PTR(-ENODEV);
 382 }
 383 EXPORT_SYMBOL_GPL(ipu_dmfc_get);
 384
 385 void ipu_dmfc_put(struct dmfc_channel *dmfc)
 386 {
 387         ipu_dmfc_free_bandwidth(dmfc);
 388 }
 389 EXPORT_SYMBOL_GPL(ipu_dmfc_put);
 390
 391 int ipu_dmfc_init(struct ipu_soc *ipu, struct device *dev, unsigned long base,
 392                 struct clk *ipu_clk)
 393 {
 394         struct ipu_dmfc_priv *priv;
 395         int i;
 396
 397         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 398         if (!priv)
 399                 return -ENOMEM;
 400
 401         priv->base = devm_ioremap(dev, base, PAGE_SIZE);
 402         if (!priv->base)
 403                 return -ENOMEM;
 404
 405         priv->dev = dev;
 406         priv->ipu = ipu;
 407         mutex_init(&priv->mutex);
 408
 409         ipu->dmfc_priv = priv;
 410
 411         for (i = 0; i < DMFC_NUM_CHANNELS; i++) {
 412                 priv->channels[i].priv = priv;
 413                 priv->channels[i].ipu = ipu;
 414                 priv->channels[i].data = &dmfcdata[i];
 415         }
 416
 417         writel(0x0, priv->base + DMFC_WR_CHAN);
 418         writel(0x0, priv->base + DMFC_DP_CHAN);
 419
 420         /*
 421          * We have a total bandwidth of clkrate * 4pixel divided
 422          * into 8 slots.
 423          */
 424         priv->bandwidth_per_slot = clk_get_rate(ipu_clk) * 4 / 8;
 425
 426         dev_dbg(dev, "dmfc: 8 slots with %ldMpixel/s bandwidth each\n",
 427                         priv->bandwidth_per_slot / 1000000);
 428
 429         writel(0x202020f6, priv->base + DMFC_WR_CHAN_DEF);
 430         writel(0x2020f6f6, priv->base + DMFC_DP_CHAN_DEF);
 431         writel(0x00000003, priv->base + DMFC_GENERAL1);
 432
 433         return 0;
 434 }
 435
 436 void ipu_dmfc_exit(struct ipu_soc *ipu)
 437 {
 438 }