drivers/video/adf/adf_fbdev.c

   1 /*
   2  * Copyright (C) 2013 Google, Inc.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  */
  14
  15 #include <linux/vmalloc.h>
  16
  17 #include <video/adf.h>
  18 #include <video/adf_client.h>
  19 #include <video/adf_fbdev.h>
  20 #include <video/adf_format.h>
  21
  22 #include "adf.h"
  23
  24 struct adf_fbdev_format {
  25         u32 fourcc;
  26         u32 bpp;
  27         u32 r_length;
  28         u32 g_length;
  29         u32 b_length;
  30         u32 a_length;
  31         u32 r_offset;
  32         u32 g_offset;
  33         u32 b_offset;
  34         u32 a_offset;
  35 };
  36
  37 static const struct adf_fbdev_format format_table[] = {
  38         {DRM_FORMAT_RGB332, 8, 3, 3, 2, 0, 5, 2, 0, 0},
  39         {DRM_FORMAT_BGR233, 8, 3, 3, 2, 0, 0, 3, 5, 0},
  40
  41         {DRM_FORMAT_XRGB4444, 16, 4, 4, 4, 0, 8, 4, 0, 0},
  42         {DRM_FORMAT_XBGR4444, 16, 4, 4, 4, 0, 0, 4, 8, 0},
  43         {DRM_FORMAT_RGBX4444, 16, 4, 4, 4, 0, 12, 8, 4, 0},
  44         {DRM_FORMAT_BGRX4444, 16, 4, 4, 4, 0, 0, 4, 8, 0},
  45
  46         {DRM_FORMAT_ARGB4444, 16, 4, 4, 4, 4, 8, 4, 0, 12},
  47         {DRM_FORMAT_ABGR4444, 16, 4, 4, 4, 4, 0, 4, 8, 12},
  48         {DRM_FORMAT_RGBA4444, 16, 4, 4, 4, 4, 12, 8, 4, 0},
  49         {DRM_FORMAT_BGRA4444, 16, 4, 4, 4, 4, 0, 4, 8, 0},
  50
  51         {DRM_FORMAT_XRGB1555, 16, 5, 5, 5, 0, 10, 5, 0, 0},
  52         {DRM_FORMAT_XBGR1555, 16, 5, 5, 5, 0, 0, 5, 10, 0},
  53         {DRM_FORMAT_RGBX5551, 16, 5, 5, 5, 0, 11, 6, 1, 0},
  54         {DRM_FORMAT_BGRX5551, 16, 5, 5, 5, 0, 1, 6, 11, 0},
  55
  56         {DRM_FORMAT_ARGB1555, 16, 5, 5, 5, 1, 10, 5, 0, 15},
  57         {DRM_FORMAT_ABGR1555, 16, 5, 5, 5, 1, 0, 5, 10, 15},
  58         {DRM_FORMAT_RGBA5551, 16, 5, 5, 5, 1, 11, 6, 1, 0},
  59         {DRM_FORMAT_BGRA5551, 16, 5, 5, 5, 1, 1, 6, 11, 0},
  60
  61         {DRM_FORMAT_RGB565, 16, 5, 6, 5, 0, 11, 5, 0, 0},
  62         {DRM_FORMAT_BGR565, 16, 5, 6, 5, 0, 0, 5, 11, 0},
  63
  64         {DRM_FORMAT_RGB888, 24, 8, 8, 8, 0, 16, 8, 0, 0},
  65         {DRM_FORMAT_BGR888, 24, 8, 8, 8, 0, 0, 8, 16, 0},
  66
  67         {DRM_FORMAT_XRGB8888, 32, 8, 8, 8, 0, 16, 8, 0, 0},
  68         {DRM_FORMAT_XBGR8888, 32, 8, 8, 8, 0, 0, 8, 16, 0},
  69         {DRM_FORMAT_RGBX8888, 32, 8, 8, 8, 0, 24, 16, 8, 0},
  70         {DRM_FORMAT_BGRX8888, 32, 8, 8, 8, 0, 8, 16, 24, 0},
  71
  72         {DRM_FORMAT_ARGB8888, 32, 8, 8, 8, 8, 16, 8, 0, 24},
  73         {DRM_FORMAT_ABGR8888, 32, 8, 8, 8, 8, 0, 8, 16, 24},
  74         {DRM_FORMAT_RGBA8888, 32, 8, 8, 8, 8, 24, 16, 8, 0},
  75         {DRM_FORMAT_BGRA8888, 32, 8, 8, 8, 8, 8, 16, 24, 0},
  76
  77         {DRM_FORMAT_XRGB2101010, 32, 10, 10, 10, 0, 20, 10, 0, 0},
  78         {DRM_FORMAT_XBGR2101010, 32, 10, 10, 10, 0, 0, 10, 20, 0},
  79         {DRM_FORMAT_RGBX1010102, 32, 10, 10, 10, 0, 22, 12, 2, 0},
  80         {DRM_FORMAT_BGRX1010102, 32, 10, 10, 10, 0, 2, 12, 22, 0},
  81
  82         {DRM_FORMAT_ARGB2101010, 32, 10, 10, 10, 2, 20, 10, 0, 30},
  83         {DRM_FORMAT_ABGR2101010, 32, 10, 10, 10, 2, 0, 10, 20, 30},
  84         {DRM_FORMAT_RGBA1010102, 32, 10, 10, 10, 2, 22, 12, 2, 0},
  85         {DRM_FORMAT_BGRA1010102, 32, 10, 10, 10, 2, 2, 12, 22, 0},
  86 };
  87
  88 static u32 drm_fourcc_from_fb_var(struct fb_var_screeninfo *var)
  89 {
  90         size_t i;
  91         for (i = 0; i < ARRAY_SIZE(format_table); i++) {
  92                 const struct adf_fbdev_format *f = &format_table[i];
  93                 if (var->red.length == f->r_length &&
  94                         var->red.offset == f->r_offset &&
  95                         var->green.length == f->g_length &&
  96                         var->green.offset == f->g_offset &&
  97                         var->blue.length == f->b_length &&
  98                         var->blue.offset == f->b_offset &&
  99                         var->transp.length == f->a_length &&
 100                         (var->transp.length == 0 ||
 101                                         var->transp.offset == f->a_offset))
 102                         return f->fourcc;
 103         }
 104
 105         return 0;
 106 }
 107
 108 static const struct adf_fbdev_format *fbdev_format_info(u32 format)
 109 {
 110         size_t i;
 111         for (i = 0; i < ARRAY_SIZE(format_table); i++) {
 112                 const struct adf_fbdev_format *f = &format_table[i];
 113                 if (f->fourcc == format)
 114                         return f;
 115         }
 116
 117         BUG();
 118 }
 119
 120 void adf_modeinfo_to_fb_videomode(const struct drm_mode_modeinfo *mode,
 121                 struct fb_videomode *vmode)
 122 {
 123         memset(vmode, 0, sizeof(*vmode));
 124
 125         vmode->refresh = mode->vrefresh;
 126
 127         vmode->xres = mode->hdisplay;
 128         vmode->yres = mode->vdisplay;
 129
 130         vmode->pixclock = mode->clock ? KHZ2PICOS(mode->clock) : 0;
 131         vmode->left_margin = mode->htotal - mode->hsync_end;
 132         vmode->right_margin = mode->hsync_start - mode->hdisplay;
 133         vmode->upper_margin = mode->vtotal - mode->vsync_end;
 134         vmode->lower_margin = mode->vsync_start - mode->vdisplay;
 135         vmode->hsync_len = mode->hsync_end - mode->hsync_start;
 136         vmode->vsync_len = mode->vsync_end - mode->vsync_start;
 137
 138         vmode->sync = 0;
 139         if (mode->flags & DRM_MODE_FLAG_PHSYNC)
 140                 vmode->sync |= FB_SYNC_HOR_HIGH_ACT;
 141         if (mode->flags & DRM_MODE_FLAG_PVSYNC)
 142                 vmode->sync |= FB_SYNC_VERT_HIGH_ACT;
 143         if (mode->flags & DRM_MODE_FLAG_PCSYNC)
 144                 vmode->sync |= FB_SYNC_COMP_HIGH_ACT;
 145         if (mode->flags & DRM_MODE_FLAG_BCAST)
 146                 vmode->sync |= FB_SYNC_BROADCAST;
 147
 148         vmode->vmode = 0;
 149         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
 150                 vmode->vmode |= FB_VMODE_INTERLACED;
 151         if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
 152                 vmode->vmode |= FB_VMODE_DOUBLE;
 153 }
 154 EXPORT_SYMBOL(adf_modeinfo_to_fb_videomode);
 155
 156 void adf_modeinfo_from_fb_videomode(const struct fb_videomode *vmode,
 157                 struct drm_mode_modeinfo *mode)
 158 {
 159         memset(mode, 0, sizeof(*mode));
 160
 161         mode->hdisplay = vmode->xres;
 162         mode->hsync_start = mode->hdisplay + vmode->right_margin;
 163         mode->hsync_end = mode->hsync_start + vmode->hsync_len;
 164         mode->htotal = mode->hsync_end + vmode->left_margin;
 165
 166         mode->vdisplay = vmode->yres;
 167         mode->vsync_start = mode->vdisplay + vmode->lower_margin;
 168         mode->vsync_end = mode->vsync_start + vmode->vsync_len;
 169         mode->vtotal = mode->vsync_end + vmode->upper_margin;
 170
 171         mode->clock = vmode->pixclock ? PICOS2KHZ(vmode->pixclock) : 0;
 172
 173         mode->flags = 0;
 174         if (vmode->sync & FB_SYNC_HOR_HIGH_ACT)
 175                 mode->flags |= DRM_MODE_FLAG_PHSYNC;
 176         if (vmode->sync & FB_SYNC_VERT_HIGH_ACT)
 177                 mode->flags |= DRM_MODE_FLAG_PVSYNC;
 178         if (vmode->sync & FB_SYNC_COMP_HIGH_ACT)
 179                 mode->flags |= DRM_MODE_FLAG_PCSYNC;
 180         if (vmode->sync & FB_SYNC_BROADCAST)
 181                 mode->flags |= DRM_MODE_FLAG_BCAST;
 182         if (vmode->vmode & FB_VMODE_INTERLACED)
 183                 mode->flags |= DRM_MODE_FLAG_INTERLACE;
 184         if (vmode->vmode & FB_VMODE_DOUBLE)
 185                 mode->flags |= DRM_MODE_FLAG_DBLSCAN;
 186
 187         if (vmode->refresh)
 188                 mode->vrefresh = vmode->refresh;
 189         else
 190                 adf_modeinfo_set_vrefresh(mode);
 191
 192         if (vmode->name)
 193                 strlcpy(mode->name, vmode->name, sizeof(mode->name));
 194         else
 195                 adf_modeinfo_set_name(mode);
 196 }
 197 EXPORT_SYMBOL(adf_modeinfo_from_fb_videomode);
 198
 199 static int adf_fbdev_post(struct adf_fbdev *fbdev)
 200 {
 201         struct adf_buffer buf;
 202         struct sync_fence *complete_fence;
 203         int ret = 0;
 204
 205         memset(&buf, 0, sizeof(buf));
 206         buf.overlay_engine = fbdev->eng;
 207         buf.w = fbdev->info->var.xres;
 208         buf.h = fbdev->info->var.yres;
 209         buf.format = fbdev->format;
 210         buf.dma_bufs[0] = fbdev->dma_buf;
 211         buf.offset[0] = fbdev->offset +
 212                         fbdev->info->var.yoffset * fbdev->pitch +
 213                         fbdev->info->var.xoffset *
 214                         (fbdev->info->var.bits_per_pixel / 8);
 215         buf.pitch[0] = fbdev->pitch;
 216         buf.n_planes = 1;
 217
 218         complete_fence = adf_interface_simple_post(fbdev->intf, &buf);
 219         if (IS_ERR(complete_fence)) {
 220                 ret = PTR_ERR(complete_fence);
 221                 goto done;
 222         }
 223
 224         sync_fence_put(complete_fence);
 225 done:
 226         return ret;
 227 }
 228
 229 static const u16 vga_palette[][3] = {
 230         {0x0000, 0x0000, 0x0000},
 231         {0x0000, 0x0000, 0xAAAA},
 232         {0x0000, 0xAAAA, 0x0000},
 233         {0x0000, 0xAAAA, 0xAAAA},
 234         {0xAAAA, 0x0000, 0x0000},
 235         {0xAAAA, 0x0000, 0xAAAA},
 236         {0xAAAA, 0x5555, 0x0000},
 237         {0xAAAA, 0xAAAA, 0xAAAA},
 238         {0x5555, 0x5555, 0x5555},
 239         {0x5555, 0x5555, 0xFFFF},
 240         {0x5555, 0xFFFF, 0x5555},
 241         {0x5555, 0xFFFF, 0xFFFF},
 242         {0xFFFF, 0x5555, 0x5555},
 243         {0xFFFF, 0x5555, 0xFFFF},
 244         {0xFFFF, 0xFFFF, 0x5555},
 245         {0xFFFF, 0xFFFF, 0xFFFF},
 246 };
 247
 248 static int adf_fb_alloc(struct adf_fbdev *fbdev)
 249 {
 250         int ret;
 251
 252         ret = adf_interface_simple_buffer_alloc(fbdev->intf,
 253                         fbdev->default_xres_virtual,
 254                         fbdev->default_yres_virtual,
 255                         fbdev->default_format,
 256                         &fbdev->dma_buf, &fbdev->offset, &fbdev->pitch);
 257         if (ret < 0) {
 258                 dev_err(fbdev->info->dev, "allocating fb failed: %d\n", ret);
 259                 return ret;
 260         }
 261
 262         fbdev->vaddr = dma_buf_vmap(fbdev->dma_buf);
 263         if (!fbdev->vaddr) {
 264                 ret = -ENOMEM;
 265                 dev_err(fbdev->info->dev, "vmapping fb failed\n");
 266                 goto err_vmap;
 267         }
 268         fbdev->info->fix.line_length = fbdev->pitch;
 269         fbdev->info->var.xres_virtual = fbdev->default_xres_virtual;
 270         fbdev->info->var.yres_virtual = fbdev->default_yres_virtual;
 271         fbdev->info->fix.smem_len = fbdev->dma_buf->size;
 272         fbdev->info->screen_base = fbdev->vaddr;
 273
 274         return 0;
 275
 276 err_vmap:
 277         dma_buf_put(fbdev->dma_buf);
 278         return ret;
 279 }
 280
 281 static void adf_fb_destroy(struct adf_fbdev *fbdev)
 282 {
 283         dma_buf_vunmap(fbdev->dma_buf, fbdev->vaddr);
 284         dma_buf_put(fbdev->dma_buf);
 285 }
 286
 287 static void adf_fbdev_set_format(struct adf_fbdev *fbdev, u32 format)
 288 {
 289         size_t i;
 290         const struct adf_fbdev_format *info = fbdev_format_info(format);
 291         for (i = 0; i < ARRAY_SIZE(vga_palette); i++) {
 292                 u16 r = vga_palette[i][0];
 293                 u16 g = vga_palette[i][1];
 294                 u16 b = vga_palette[i][2];
 295
 296                 r >>= (16 - info->r_length);
 297                 g >>= (16 - info->g_length);
 298                 b >>= (16 - info->b_length);
 299
 300                 fbdev->pseudo_palette[i] =
 301                         (r << info->r_offset) |
 302                         (g << info->g_offset) |
 303                         (b << info->b_offset);
 304
 305                 if (info->a_length) {
 306                         u16 a = BIT(info->a_length) - 1;
 307                         fbdev->pseudo_palette[i] |= (a << info->a_offset);
 308                 }
 309         }
 310
 311         fbdev->info->var.bits_per_pixel = adf_format_bpp(format);
 312         fbdev->info->var.red.length = info->r_length;
 313         fbdev->info->var.red.offset = info->r_offset;
 314         fbdev->info->var.green.length = info->g_length;
 315         fbdev->info->var.green.offset = info->g_offset;
 316         fbdev->info->var.blue.length = info->b_length;
 317         fbdev->info->var.blue.offset = info->b_offset;
 318         fbdev->info->var.transp.length = info->a_length;
 319         fbdev->info->var.transp.offset = info->a_offset;
 320         fbdev->format = format;
 321 }
 322
 323 static void adf_fbdev_fill_modelist(struct adf_fbdev *fbdev)
 324 {
 325         struct drm_mode_modeinfo *modelist;
 326         struct fb_videomode fbmode;
 327         size_t n_modes, i;
 328         int ret = 0;
 329
 330         n_modes = adf_interface_modelist(fbdev->intf, NULL, 0);
 331         modelist = kzalloc(sizeof(modelist[0]) * n_modes, GFP_KERNEL);
 332         if (!modelist) {
 333                 dev_warn(fbdev->info->dev, "allocating new modelist failed; keeping old modelist\n");
 334                 return;
 335         }
 336         adf_interface_modelist(fbdev->intf, modelist, n_modes);
 337
 338         fb_destroy_modelist(&fbdev->info->modelist);
 339
 340         for (i = 0; i < n_modes; i++) {
 341                 adf_modeinfo_to_fb_videomode(&modelist[i], &fbmode);
 342                 ret = fb_add_videomode(&fbmode, &fbdev->info->modelist);
 343                 if (ret < 0)
 344                         dev_warn(fbdev->info->dev, "adding mode %s to modelist failed: %d\n",
 345                                         modelist[i].name, ret);
 346         }
 347
 348         kfree(modelist);
 349 }
 350
 351 /**
 352  * adf_fbdev_open - default implementation of fbdev open op
 353  */
 354 int adf_fbdev_open(struct fb_info *info, int user)
 355 {
 356         struct adf_fbdev *fbdev = info->par;
 357         int ret;
 358
 359         mutex_lock(&fbdev->refcount_lock);
 360
 361         if (unlikely(fbdev->refcount == UINT_MAX)) {
 362                 ret = -EMFILE;
 363                 goto done;
 364         }
 365
 366         if (!fbdev->refcount) {
 367                 struct drm_mode_modeinfo mode;
 368                 struct fb_videomode fbmode;
 369                 struct adf_device *dev = adf_interface_parent(fbdev->intf);
 370
 371                 ret = adf_device_attach(dev, fbdev->eng, fbdev->intf);
 372                 if (ret < 0 && ret != -EALREADY)
 373                         goto done;
 374
 375                 ret = adf_fb_alloc(fbdev);
 376                 if (ret < 0)
 377                         goto done;
 378
 379                 adf_interface_current_mode(fbdev->intf, &mode);
 380                 adf_modeinfo_to_fb_videomode(&mode, &fbmode);
 381                 fb_videomode_to_var(&fbdev->info->var, &fbmode);
 382
 383                 adf_fbdev_set_format(fbdev, fbdev->default_format);
 384                 adf_fbdev_fill_modelist(fbdev);
 385         }
 386
 387         ret = adf_fbdev_post(fbdev);
 388         if (ret < 0) {
 389                 if (!fbdev->refcount)
 390                         adf_fb_destroy(fbdev);
 391                 goto done;
 392         }
 393
 394         fbdev->refcount++;
 395 done:
 396         mutex_unlock(&fbdev->refcount_lock);
 397         return ret;
 398 }
 399 EXPORT_SYMBOL(adf_fbdev_open);
 400
 401 /**
 402  * adf_fbdev_release - default implementation of fbdev release op
 403  */
 404 int adf_fbdev_release(struct fb_info *info, int user)
 405 {
 406         struct adf_fbdev *fbdev = info->par;
 407         mutex_lock(&fbdev->refcount_lock);
 408         BUG_ON(!fbdev->refcount);
 409         fbdev->refcount--;
 410         if (!fbdev->refcount)
 411                 adf_fb_destroy(fbdev);
 412         mutex_unlock(&fbdev->refcount_lock);
 413         return 0;
 414 }
 415 EXPORT_SYMBOL(adf_fbdev_release);
 416
 417 /**
 418  * adf_fbdev_check_var - default implementation of fbdev check_var op
 419  */
 420 int adf_fbdev_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 421 {
 422         struct adf_fbdev *fbdev = info->par;
 423         bool valid_format = true;
 424         u32 format = drm_fourcc_from_fb_var(var);
 425         u32 pitch = var->xres_virtual * var->bits_per_pixel / 8;
 426
 427         if (!format) {
 428                 dev_dbg(info->dev, "%s: unrecognized format\n", __func__);
 429                 valid_format = false;
 430         }
 431
 432         if (valid_format && var->grayscale) {
 433                 dev_dbg(info->dev, "%s: grayscale modes not supported\n",
 434                                 __func__);
 435                 valid_format = false;
 436         }
 437
 438         if (valid_format && var->nonstd) {
 439                 dev_dbg(info->dev, "%s: nonstandard formats not supported\n",
 440                                 __func__);
 441                 valid_format = false;
 442         }
 443
 444         if (valid_format && !adf_overlay_engine_supports_format(fbdev->eng,
 445                         format)) {
 446                 char format_str[ADF_FORMAT_STR_SIZE];
 447                 adf_format_str(format, format_str);
 448                 dev_dbg(info->dev, "%s: format %s not supported by overlay engine %s\n",
 449                                 __func__, format_str, fbdev->eng->base.name);
 450                 valid_format = false;
 451         }
 452
 453         if (valid_format && pitch > fbdev->pitch) {
 454                 dev_dbg(info->dev, "%s: fb pitch too small for var (pitch = %u, xres_virtual = %u, bits_per_pixel = %u)\n",
 455                                 __func__, fbdev->pitch, var->xres_virtual,
 456                                 var->bits_per_pixel);
 457                 valid_format = false;
 458         }
 459
 460         if (valid_format && var->yres_virtual > fbdev->default_yres_virtual) {
 461                 dev_dbg(info->dev, "%s: fb height too small for var (h = %u, yres_virtual = %u)\n",
 462                                 __func__, fbdev->default_yres_virtual,
 463                                 var->yres_virtual);
 464                 valid_format = false;
 465         }
 466
 467         if (valid_format) {
 468                 var->activate = info->var.activate;
 469                 var->height = info->var.height;
 470                 var->width = info->var.width;
 471                 var->accel_flags = info->var.accel_flags;
 472                 var->rotate = info->var.rotate;
 473                 var->colorspace = info->var.colorspace;
 474                 /* userspace can't change these */
 475         } else {
 476                 /* if any part of the format is invalid then fixing it up is
 477                    impractical, so save just the modesetting bits and
 478                    overwrite everything else */
 479                 struct fb_videomode mode;
 480                 fb_var_to_videomode(&mode, var);
 481                 memcpy(var, &info->var, sizeof(*var));
 482                 fb_videomode_to_var(var, &mode);
 483         }
 484
 485         return 0;
 486 }
 487 EXPORT_SYMBOL(adf_fbdev_check_var);
 488
 489 /**
 490  * adf_fbdev_set_par - default implementation of fbdev set_par op
 491  */
 492 int adf_fbdev_set_par(struct fb_info *info)
 493 {
 494         struct adf_fbdev *fbdev = info->par;
 495         struct adf_interface *intf = fbdev->intf;
 496         struct fb_videomode vmode;
 497         struct drm_mode_modeinfo mode;
 498         int ret;
 499         u32 format = drm_fourcc_from_fb_var(&info->var);
 500
 501         fb_var_to_videomode(&vmode, &info->var);
 502         adf_modeinfo_from_fb_videomode(&vmode, &mode);
 503         ret = adf_interface_set_mode(intf, &mode);
 504         if (ret < 0)
 505                 return ret;
 506
 507         ret = adf_fbdev_post(fbdev);
 508         if (ret < 0)
 509                 return ret;
 510
 511         if (format != fbdev->format)
 512                 adf_fbdev_set_format(fbdev, format);
 513
 514         return 0;
 515 }
 516 EXPORT_SYMBOL(adf_fbdev_set_par);
 517
 518 /**
 519  * adf_fbdev_blank - default implementation of fbdev blank op
 520  */
 521 int adf_fbdev_blank(int blank, struct fb_info *info)
 522 {
 523         struct adf_fbdev *fbdev = info->par;
 524         struct adf_interface *intf = fbdev->intf;
 525         u8 dpms_state;
 526
 527         switch (blank) {
 528         case FB_BLANK_UNBLANK:
 529                 dpms_state = DRM_MODE_DPMS_ON;
 530                 break;
 531         case FB_BLANK_NORMAL:
 532                 dpms_state = DRM_MODE_DPMS_STANDBY;
 533                 break;
 534         case FB_BLANK_VSYNC_SUSPEND:
 535                 dpms_state = DRM_MODE_DPMS_SUSPEND;
 536                 break;
 537         case FB_BLANK_HSYNC_SUSPEND:
 538                 dpms_state = DRM_MODE_DPMS_STANDBY;
 539                 break;
 540         case FB_BLANK_POWERDOWN:
 541                 dpms_state = DRM_MODE_DPMS_OFF;
 542                 break;
 543         default:
 544                 return -EINVAL;
 545         }
 546
 547         return adf_interface_blank(intf, dpms_state);
 548 }
 549 EXPORT_SYMBOL(adf_fbdev_blank);
 550
 551 /**
 552  * adf_fbdev_pan_display - default implementation of fbdev pan_display op
 553  */
 554 int adf_fbdev_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 555 {
 556         struct adf_fbdev *fbdev = info->par;
 557         return adf_fbdev_post(fbdev);
 558 }
 559 EXPORT_SYMBOL(adf_fbdev_pan_display);
 560
 561 /**
 562  * adf_fbdev_mmap - default implementation of fbdev mmap op
 563  */
 564 int adf_fbdev_mmap(struct fb_info *info, struct vm_area_struct *vma)
 565 {
 566         struct adf_fbdev *fbdev = info->par;
 567
 568         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 569         return dma_buf_mmap(fbdev->dma_buf, vma, 0);
 570 }
 571 EXPORT_SYMBOL(adf_fbdev_mmap);
 572
 573 /**
 574  * adf_fbdev_init - initialize helper to wrap ADF device in fbdev API
 575  *
 576  * @fbdev: the fbdev helper
 577  * @interface: the ADF interface that will display the framebuffer
 578  * @eng: the ADF overlay engine that will scan out the framebuffer
 579  * @xres_virtual: the virtual width of the framebuffer
 580  * @yres_virtual: the virtual height of the framebuffer
 581  * @format: the format of the framebuffer
 582  * @fbops: the device's fbdev ops
 583  * @fmt: formatting for the framebuffer identification string
 584  * @...: variable arguments
 585  *
 586  * @format must be a standard, non-indexed RGB format, i.e.,
 587  * adf_format_is_rgb(@format) && @format != @DRM_FORMAT_C8.
 588  *
 589  * Returns 0 on success or -errno on failure.
 590  */
 591 int adf_fbdev_init(struct adf_fbdev *fbdev, struct adf_interface *interface,
 592                 struct adf_overlay_engine *eng,
 593                 u16 xres_virtual, u16 yres_virtual, u32 format,
 594                 struct fb_ops *fbops, const char *fmt, ...)
 595 {
 596         struct adf_device *parent = adf_interface_parent(interface);
 597         struct device *dev = &parent->base.dev;
 598         u16 width_mm, height_mm;
 599         va_list args;
 600         int ret;
 601
 602         if (!adf_format_is_rgb(format) ||
 603                         format == DRM_FORMAT_C8) {
 604                 dev_err(dev, "fbdev helper does not support format %u\n",
 605                                 format);
 606                 return -EINVAL;
 607         }
 608
 609         memset(fbdev, 0, sizeof(*fbdev));
 610         fbdev->intf = interface;
 611         fbdev->eng = eng;
 612         fbdev->info = framebuffer_alloc(0, dev);
 613         if (!fbdev->info) {
 614                 dev_err(dev, "allocating framebuffer device failed\n");
 615                 return -ENOMEM;
 616         }
 617         mutex_init(&fbdev->refcount_lock);
 618         fbdev->default_xres_virtual = xres_virtual;
 619         fbdev->default_yres_virtual = yres_virtual;
 620         fbdev->default_format = format;
 621
 622         fbdev->info->flags = FBINFO_FLAG_DEFAULT;
 623         ret = adf_interface_get_screen_size(interface, &width_mm, &height_mm);
 624         if (ret < 0) {
 625                 width_mm = 0;
 626                 height_mm = 0;
 627         }
 628         fbdev->info->var.width = width_mm;
 629         fbdev->info->var.height = height_mm;
 630         fbdev->info->var.activate = FB_ACTIVATE_VBL;
 631         va_start(args, fmt);
 632         vsnprintf(fbdev->info->fix.id, sizeof(fbdev->info->fix.id), fmt, args);
 633         va_end(args);
 634         fbdev->info->fix.type = FB_TYPE_PACKED_PIXELS;
 635         fbdev->info->fix.visual = FB_VISUAL_TRUECOLOR;
 636         fbdev->info->fix.xpanstep = 1;
 637         fbdev->info->fix.ypanstep = 1;
 638         INIT_LIST_HEAD(&fbdev->info->modelist);
 639         fbdev->info->fbops = fbops;
 640         fbdev->info->pseudo_palette = fbdev->pseudo_palette;
 641         fbdev->info->par = fbdev;
 642
 643         ret = register_framebuffer(fbdev->info);
 644         if (ret < 0) {
 645                 dev_err(dev, "registering framebuffer failed: %d\n", ret);
 646                 return ret;
 647         }
 648
 649         return 0;
 650 }
 651 EXPORT_SYMBOL(adf_fbdev_init);
 652
 653 /**
 654  * adf_fbdev_destroy - destroy helper to wrap ADF device in fbdev API
 655  *
 656  * @fbdev: the fbdev helper
 657  */
 658 void adf_fbdev_destroy(struct adf_fbdev *fbdev)
 659 {
 660         unregister_framebuffer(fbdev->info);
 661         BUG_ON(fbdev->refcount);
 662         mutex_destroy(&fbdev->refcount_lock);
 663         framebuffer_release(fbdev->info);
 664 }
 665 EXPORT_SYMBOL(adf_fbdev_destroy);