drivers/staging/gma500/psb_2d.c

   1 /**************************************************************************
   2  * Copyright (c) 2007, Intel Corporation.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope 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, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
  19  * develop this driver.
  20  *
  21  **************************************************************************/
  22
  23 #include <linux/module.h>
  24 #include <linux/kernel.h>
  25 #include <linux/errno.h>
  26 #include <linux/string.h>
  27 #include <linux/mm.h>
  28 #include <linux/tty.h>
  29 #include <linux/slab.h>
  30 #include <linux/delay.h>
  31 #include <linux/fb.h>
  32 #include <linux/init.h>
  33 #include <linux/console.h>
  34
  35 #include <drm/drmP.h>
  36 #include <drm/drm.h>
  37 #include <drm/drm_crtc.h>
  38
  39 #include "psb_drv.h"
  40 #include "psb_reg.h"
  41 #include "psb_drv.h"
  42 #include "psb_fb.h"
  43 #include "psb_sgx.h"
  44
  45 void psb_spank(struct drm_psb_private *dev_priv)
  46 {
  47         PSB_WSGX32(_PSB_CS_RESET_BIF_RESET | _PSB_CS_RESET_DPM_RESET |
  48                 _PSB_CS_RESET_TA_RESET | _PSB_CS_RESET_USE_RESET |
  49                 _PSB_CS_RESET_ISP_RESET | _PSB_CS_RESET_TSP_RESET |
  50                 _PSB_CS_RESET_TWOD_RESET, PSB_CR_SOFT_RESET);
  51         (void) PSB_RSGX32(PSB_CR_SOFT_RESET);
  52
  53         msleep(1);
  54
  55         PSB_WSGX32(0, PSB_CR_SOFT_RESET);
  56         wmb();
  57         PSB_WSGX32(PSB_RSGX32(PSB_CR_BIF_CTRL) | _PSB_CB_CTRL_CLEAR_FAULT,
  58                    PSB_CR_BIF_CTRL);
  59         wmb();
  60         (void) PSB_RSGX32(PSB_CR_BIF_CTRL);
  61
  62         msleep(1);
  63         PSB_WSGX32(PSB_RSGX32(PSB_CR_BIF_CTRL) & ~_PSB_CB_CTRL_CLEAR_FAULT,
  64                    PSB_CR_BIF_CTRL);
  65         (void) PSB_RSGX32(PSB_CR_BIF_CTRL);
  66         PSB_WSGX32(dev_priv->pg->gatt_start, PSB_CR_BIF_TWOD_REQ_BASE);
  67 }
  68
  69 static int psb_2d_wait_available(struct drm_psb_private *dev_priv,
  70                           unsigned size)
  71 {
  72         uint32_t avail = PSB_RSGX32(PSB_CR_2D_SOCIF);
  73         unsigned long t = jiffies + HZ;
  74
  75         while(avail < size) {
  76                 avail = PSB_RSGX32(PSB_CR_2D_SOCIF);
  77                 if (time_after(jiffies, t)) {
  78                         psb_spank(dev_priv);
  79                         return -EIO;
  80                 }
  81         }
  82         return 0;
  83 }
  84
  85 /* FIXME: Remember if we expose the 2D engine to the DRM we need to serialize
  86    it with console use */
  87
  88 static int psbfb_2d_submit(struct drm_psb_private *dev_priv, uint32_t *cmdbuf,
  89                            unsigned size)
  90 {
  91         int ret = 0;
  92         int i;
  93         unsigned submit_size;
  94
  95         while (size > 0) {
  96                 submit_size = (size < 0x60) ? size : 0x60;
  97                 size -= submit_size;
  98                 ret = psb_2d_wait_available(dev_priv, submit_size);
  99                 if (ret)
 100                         return ret;
 101
 102                 submit_size <<= 2;
 103                 for (i = 0; i < submit_size; i += 4) {
 104                         PSB_WSGX32(*cmdbuf++, PSB_SGX_2D_SLAVE_PORT + i);
 105                 }
 106                 (void)PSB_RSGX32(PSB_SGX_2D_SLAVE_PORT + i - 4);
 107         }
 108         return 0;
 109 }
 110
 111 static int psb_accel_2d_fillrect(struct drm_psb_private *dev_priv,
 112                                  uint32_t dst_offset, uint32_t dst_stride,
 113                                  uint32_t dst_format, uint16_t dst_x,
 114                                  uint16_t dst_y, uint16_t size_x,
 115                                  uint16_t size_y, uint32_t fill)
 116 {
 117         uint32_t buffer[10];
 118         uint32_t *buf;
 119
 120         buf = buffer;
 121
 122         *buf++ = PSB_2D_FENCE_BH;
 123
 124         *buf++ =
 125             PSB_2D_DST_SURF_BH | dst_format | (dst_stride <<
 126                                                PSB_2D_DST_STRIDE_SHIFT);
 127         *buf++ = dst_offset;
 128
 129         *buf++ =
 130             PSB_2D_BLIT_BH |
 131             PSB_2D_ROT_NONE |
 132             PSB_2D_COPYORDER_TL2BR |
 133             PSB_2D_DSTCK_DISABLE |
 134             PSB_2D_SRCCK_DISABLE | PSB_2D_USE_FILL | PSB_2D_ROP3_PATCOPY;
 135
 136         *buf++ = fill << PSB_2D_FILLCOLOUR_SHIFT;
 137         *buf++ =
 138             (dst_x << PSB_2D_DST_XSTART_SHIFT) | (dst_y <<
 139                                                   PSB_2D_DST_YSTART_SHIFT);
 140         *buf++ =
 141             (size_x << PSB_2D_DST_XSIZE_SHIFT) | (size_y <<
 142                                                   PSB_2D_DST_YSIZE_SHIFT);
 143         *buf++ = PSB_2D_FLUSH_BH;
 144
 145         return psbfb_2d_submit(dev_priv, buffer, buf - buffer);
 146 }
 147
 148 static void psbfb_fillrect_accel(struct fb_info *info,
 149                                  const struct fb_fillrect *r)
 150 {
 151         struct psb_fbdev *fbdev = info->par;
 152         struct psb_framebuffer *psbfb = fbdev->pfb;
 153         struct drm_device *dev = psbfb->base.dev;
 154         struct drm_framebuffer *fb = fbdev->psb_fb_helper.fb;
 155         struct drm_psb_private *dev_priv = dev->dev_private;
 156
 157         uint32_t offset;
 158         uint32_t stride;
 159         uint32_t format;
 160
 161         if (!fb)
 162                 return;
 163
 164         offset = psbfb->offset;
 165         stride = fb->pitch;
 166
 167         switch (fb->depth) {
 168         case 8:
 169                 format = PSB_2D_DST_332RGB;
 170                 break;
 171         case 15:
 172                 format = PSB_2D_DST_555RGB;
 173                 break;
 174         case 16:
 175                 format = PSB_2D_DST_565RGB;
 176                 break;
 177         case 24:
 178         case 32:
 179                 /* this is wrong but since we don't do blending its okay */
 180                 format = PSB_2D_DST_8888ARGB;
 181                 break;
 182         default:
 183                 /* software fallback */
 184                 cfb_fillrect(info, r);
 185                 return;
 186         }
 187
 188         psb_accel_2d_fillrect(dev_priv,
 189                               offset, stride, format,
 190                               r->dx, r->dy, r->width, r->height, r->color);
 191 }
 192
 193 void psbfb_fillrect(struct fb_info *info,
 194                            const struct fb_fillrect *rect)
 195 {
 196         if (unlikely(info->state != FBINFO_STATE_RUNNING))
 197                 return;
 198
 199         if (1 || (info->flags & FBINFO_HWACCEL_DISABLED))
 200                 return cfb_fillrect(info, rect);
 201
 202         /*psb_check_power_state(dev, PSB_DEVICE_SGX); */
 203         psbfb_fillrect_accel(info, rect);
 204         /* Drop power again here on MRST FIXMEAC */
 205 }
 206
 207 static u32 psb_accel_2d_copy_direction(int xdir, int ydir)
 208 {
 209         if (xdir < 0)
 210                 return (ydir < 0) ? PSB_2D_COPYORDER_BR2TL :
 211                                         PSB_2D_COPYORDER_TR2BL;
 212         else
 213                 return (ydir < 0) ? PSB_2D_COPYORDER_BL2TR :
 214                                         PSB_2D_COPYORDER_TL2BR;
 215 }
 216
 217 /*
 218  * @src_offset in bytes
 219  * @src_stride in bytes
 220  * @src_format psb 2D format defines
 221  * @dst_offset in bytes
 222  * @dst_stride in bytes
 223  * @dst_format psb 2D format defines
 224  * @src_x offset in pixels
 225  * @src_y offset in pixels
 226  * @dst_x offset in pixels
 227  * @dst_y offset in pixels
 228  * @size_x of the copied area
 229  * @size_y of the copied area
 230  */
 231 static int psb_accel_2d_copy(struct drm_psb_private *dev_priv,
 232                              uint32_t src_offset, uint32_t src_stride,
 233                              uint32_t src_format, uint32_t dst_offset,
 234                              uint32_t dst_stride, uint32_t dst_format,
 235                              uint16_t src_x, uint16_t src_y,
 236                              uint16_t dst_x, uint16_t dst_y,
 237                              uint16_t size_x, uint16_t size_y)
 238 {
 239         uint32_t blit_cmd;
 240         uint32_t buffer[10];
 241         uint32_t *buf;
 242         uint32_t direction;
 243
 244         buf = buffer;
 245
 246         direction =
 247             psb_accel_2d_copy_direction(src_x - dst_x, src_y - dst_y);
 248
 249         if (direction == PSB_2D_COPYORDER_BR2TL ||
 250             direction == PSB_2D_COPYORDER_TR2BL) {
 251                 src_x += size_x - 1;
 252                 dst_x += size_x - 1;
 253         }
 254         if (direction == PSB_2D_COPYORDER_BR2TL ||
 255             direction == PSB_2D_COPYORDER_BL2TR) {
 256                 src_y += size_y - 1;
 257                 dst_y += size_y - 1;
 258         }
 259
 260         blit_cmd =
 261             PSB_2D_BLIT_BH |
 262             PSB_2D_ROT_NONE |
 263             PSB_2D_DSTCK_DISABLE |
 264             PSB_2D_SRCCK_DISABLE |
 265             PSB_2D_USE_PAT | PSB_2D_ROP3_SRCCOPY | direction;
 266
 267         *buf++ = PSB_2D_FENCE_BH;
 268         *buf++ =
 269             PSB_2D_DST_SURF_BH | dst_format | (dst_stride <<
 270                                                PSB_2D_DST_STRIDE_SHIFT);
 271         *buf++ = dst_offset;
 272         *buf++ =
 273             PSB_2D_SRC_SURF_BH | src_format | (src_stride <<
 274                                                PSB_2D_SRC_STRIDE_SHIFT);
 275         *buf++ = src_offset;
 276         *buf++ =
 277             PSB_2D_SRC_OFF_BH | (src_x << PSB_2D_SRCOFF_XSTART_SHIFT) |
 278             (src_y << PSB_2D_SRCOFF_YSTART_SHIFT);
 279         *buf++ = blit_cmd;
 280         *buf++ =
 281             (dst_x << PSB_2D_DST_XSTART_SHIFT) | (dst_y <<
 282                                                   PSB_2D_DST_YSTART_SHIFT);
 283         *buf++ =
 284             (size_x << PSB_2D_DST_XSIZE_SHIFT) | (size_y <<
 285                                                   PSB_2D_DST_YSIZE_SHIFT);
 286         *buf++ = PSB_2D_FLUSH_BH;
 287
 288         return psbfb_2d_submit(dev_priv, buffer, buf - buffer);
 289 }
 290
 291 static void psbfb_copyarea_accel(struct fb_info *info,
 292                                  const struct fb_copyarea *a)
 293 {
 294         struct psb_fbdev *fbdev = info->par;
 295         struct psb_framebuffer *psbfb = fbdev->pfb;
 296         struct drm_device *dev = psbfb->base.dev;
 297         struct drm_framebuffer *fb = fbdev->psb_fb_helper.fb;
 298         struct drm_psb_private *dev_priv = dev->dev_private;
 299         uint32_t offset;
 300         uint32_t stride;
 301         uint32_t src_format;
 302         uint32_t dst_format;
 303
 304         if (!fb)
 305                 return;
 306
 307         offset = psbfb->offset;
 308         stride = fb->pitch;
 309
 310         switch (fb->depth) {
 311         case 8:
 312                 src_format = PSB_2D_SRC_332RGB;
 313                 dst_format = PSB_2D_DST_332RGB;
 314                 break;
 315         case 15:
 316                 src_format = PSB_2D_SRC_555RGB;
 317                 dst_format = PSB_2D_DST_555RGB;
 318                 break;
 319         case 16:
 320                 src_format = PSB_2D_SRC_565RGB;
 321                 dst_format = PSB_2D_DST_565RGB;
 322                 break;
 323         case 24:
 324         case 32:
 325                 /* this is wrong but since we don't do blending its okay */
 326                 src_format = PSB_2D_SRC_8888ARGB;
 327                 dst_format = PSB_2D_DST_8888ARGB;
 328                 break;
 329         default:
 330                 /* software fallback */
 331                 cfb_copyarea(info, a);
 332                 return;
 333         }
 334
 335         psb_accel_2d_copy(dev_priv,
 336                           offset, stride, src_format,
 337                           offset, stride, dst_format,
 338                           a->sx, a->sy, a->dx, a->dy, a->width, a->height);
 339 }
 340
 341 void psbfb_copyarea(struct fb_info *info,
 342                            const struct fb_copyarea *region)
 343 {
 344         if (unlikely(info->state != FBINFO_STATE_RUNNING))
 345                 return;
 346
 347         if (1 || (info->flags & FBINFO_HWACCEL_DISABLED))
 348                 return cfb_copyarea(info, region);
 349
 350         /* psb_check_power_state(dev, PSB_DEVICE_SGX); */
 351         psbfb_copyarea_accel(info, region);
 352         /* Need to power back off here for MRST FIXMEAC */
 353 }
 354
 355 void psbfb_imageblit(struct fb_info *info, const struct fb_image *image)
 356 {
 357         /* For now */
 358         cfb_imageblit(info, image);
 359 }
 360
 361 int psbfb_sync(struct fb_info *info)
 362 {
 363         struct psb_fbdev *fbdev = info->par;
 364         struct psb_framebuffer *psbfb = fbdev->pfb;
 365         struct drm_device *dev = psbfb->base.dev;
 366         struct drm_psb_private *dev_priv = dev->dev_private;
 367         unsigned long _end = jiffies + DRM_HZ;
 368         int busy = 0;
 369
 370 #if 0
 371         /* Just a way to quickly test if cmd issue explodes */
 372         u32 test[2] = {
 373                 PSB_2D_FENCE_BH,
 374         };
 375         psbfb_2d_submit(dev_priv, test, 1);
 376 #endif
 377         /*
 378          * First idle the 2D engine.
 379          */
 380
 381         if ((PSB_RSGX32(PSB_CR_2D_SOCIF) == _PSB_C2_SOCIF_EMPTY) &&
 382             ((PSB_RSGX32(PSB_CR_2D_BLIT_STATUS) & _PSB_C2B_STATUS_BUSY) == 0))
 383                 goto out;
 384
 385         do {
 386                 busy = (PSB_RSGX32(PSB_CR_2D_SOCIF) != _PSB_C2_SOCIF_EMPTY);
 387                 cpu_relax();
 388         } while (busy && !time_after_eq(jiffies, _end));
 389
 390         if (busy)
 391                 busy = (PSB_RSGX32(PSB_CR_2D_SOCIF) != _PSB_C2_SOCIF_EMPTY);
 392         if (busy)
 393                 goto out;
 394
 395         do {
 396                 busy = ((PSB_RSGX32(PSB_CR_2D_BLIT_STATUS) &
 397                                                 _PSB_C2B_STATUS_BUSY) != 0);
 398                 cpu_relax();
 399         } while (busy && !time_after_eq(jiffies, _end));
 400         if (busy)
 401                 busy = ((PSB_RSGX32(PSB_CR_2D_BLIT_STATUS) &
 402                                         _PSB_C2B_STATUS_BUSY) != 0);
 403
 404 out:
 405         return (busy) ? -EBUSY : 0;
 406 }
 407
 408 /*
 409         info->fix.accel = FB_ACCEL_I830;
 410         info->flags = FBINFO_DEFAULT;
 411 */