drivers/gpu/drm/shmobile/shmob_drm_crtc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * shmob_drm_crtc.c  --  SH Mobile DRM CRTCs
   4  *
   5  * Copyright (C) 2012 Renesas Electronics Corporation
   6  *
   7  * Laurent Pinchart ([email protected])
   8  */
   9
  10 #include <linux/backlight.h>
  11 #include <linux/clk.h>
  12
  13 #include <drm/drmP.h>
  14 #include <drm/drm_crtc.h>
  15 #include <drm/drm_crtc_helper.h>
  16 #include <drm/drm_fb_cma_helper.h>
  17 #include <drm/drm_gem_cma_helper.h>
  18 #include <drm/drm_plane_helper.h>
  19
  20 #include "shmob_drm_backlight.h"
  21 #include "shmob_drm_crtc.h"
  22 #include "shmob_drm_drv.h"
  23 #include "shmob_drm_kms.h"
  24 #include "shmob_drm_plane.h"
  25 #include "shmob_drm_regs.h"
  26
  27 /*
  28  * TODO: panel support
  29  */
  30
  31 /* -----------------------------------------------------------------------------
  32  * Clock management
  33  */
  34
  35 static int shmob_drm_clk_on(struct shmob_drm_device *sdev)
  36 {
  37         int ret;
  38
  39         if (sdev->clock) {
  40                 ret = clk_prepare_enable(sdev->clock);
  41                 if (ret < 0)
  42                         return ret;
  43         }
  44
  45         return 0;
  46 }
  47
  48 static void shmob_drm_clk_off(struct shmob_drm_device *sdev)
  49 {
  50         if (sdev->clock)
  51                 clk_disable_unprepare(sdev->clock);
  52 }
  53
  54 /* -----------------------------------------------------------------------------
  55  * CRTC
  56  */
  57
  58 static void shmob_drm_crtc_setup_geometry(struct shmob_drm_crtc *scrtc)
  59 {
  60         struct drm_crtc *crtc = &scrtc->crtc;
  61         struct shmob_drm_device *sdev = crtc->dev->dev_private;
  62         const struct shmob_drm_interface_data *idata = &sdev->pdata->iface;
  63         const struct drm_display_mode *mode = &crtc->mode;
  64         u32 value;
  65
  66         value = sdev->ldmt1r
  67               | ((mode->flags & DRM_MODE_FLAG_PVSYNC) ? 0 : LDMT1R_VPOL)
  68               | ((mode->flags & DRM_MODE_FLAG_PHSYNC) ? 0 : LDMT1R_HPOL)
  69               | ((idata->flags & SHMOB_DRM_IFACE_FL_DWPOL) ? LDMT1R_DWPOL : 0)
  70               | ((idata->flags & SHMOB_DRM_IFACE_FL_DIPOL) ? LDMT1R_DIPOL : 0)
  71               | ((idata->flags & SHMOB_DRM_IFACE_FL_DAPOL) ? LDMT1R_DAPOL : 0)
  72               | ((idata->flags & SHMOB_DRM_IFACE_FL_HSCNT) ? LDMT1R_HSCNT : 0)
  73               | ((idata->flags & SHMOB_DRM_IFACE_FL_DWCNT) ? LDMT1R_DWCNT : 0);
  74         lcdc_write(sdev, LDMT1R, value);
  75
  76         if (idata->interface >= SHMOB_DRM_IFACE_SYS8A &&
  77             idata->interface <= SHMOB_DRM_IFACE_SYS24) {
  78                 /* Setup SYS bus. */
  79                 value = (idata->sys.cs_setup << LDMT2R_CSUP_SHIFT)
  80                       | (idata->sys.vsync_active_high ? LDMT2R_RSV : 0)
  81                       | (idata->sys.vsync_dir_input ? LDMT2R_VSEL : 0)
  82                       | (idata->sys.write_setup << LDMT2R_WCSC_SHIFT)
  83                       | (idata->sys.write_cycle << LDMT2R_WCEC_SHIFT)
  84                       | (idata->sys.write_strobe << LDMT2R_WCLW_SHIFT);
  85                 lcdc_write(sdev, LDMT2R, value);
  86
  87                 value = (idata->sys.read_latch << LDMT3R_RDLC_SHIFT)
  88                       | (idata->sys.read_setup << LDMT3R_RCSC_SHIFT)
  89                       | (idata->sys.read_cycle << LDMT3R_RCEC_SHIFT)
  90                       | (idata->sys.read_strobe << LDMT3R_RCLW_SHIFT);
  91                 lcdc_write(sdev, LDMT3R, value);
  92         }
  93
  94         value = ((mode->hdisplay / 8) << 16)                    /* HDCN */
  95               | (mode->htotal / 8);                             /* HTCN */
  96         lcdc_write(sdev, LDHCNR, value);
  97
  98         value = (((mode->hsync_end - mode->hsync_start) / 8) << 16) /* HSYNW */
  99               | (mode->hsync_start / 8);                        /* HSYNP */
 100         lcdc_write(sdev, LDHSYNR, value);
 101
 102         value = ((mode->hdisplay & 7) << 24) | ((mode->htotal & 7) << 16)
 103               | (((mode->hsync_end - mode->hsync_start) & 7) << 8)
 104               | (mode->hsync_start & 7);
 105         lcdc_write(sdev, LDHAJR, value);
 106
 107         value = ((mode->vdisplay) << 16)                        /* VDLN */
 108               | mode->vtotal;                                   /* VTLN */
 109         lcdc_write(sdev, LDVLNR, value);
 110
 111         value = ((mode->vsync_end - mode->vsync_start) << 16)   /* VSYNW */
 112               | mode->vsync_start;                              /* VSYNP */
 113         lcdc_write(sdev, LDVSYNR, value);
 114 }
 115
 116 static void shmob_drm_crtc_start_stop(struct shmob_drm_crtc *scrtc, bool start)
 117 {
 118         struct shmob_drm_device *sdev = scrtc->crtc.dev->dev_private;
 119         u32 value;
 120
 121         value = lcdc_read(sdev, LDCNT2R);
 122         if (start)
 123                 lcdc_write(sdev, LDCNT2R, value | LDCNT2R_DO);
 124         else
 125                 lcdc_write(sdev, LDCNT2R, value & ~LDCNT2R_DO);
 126
 127         /* Wait until power is applied/stopped. */
 128         while (1) {
 129                 value = lcdc_read(sdev, LDPMR) & LDPMR_LPS;
 130                 if ((start && value) || (!start && !value))
 131                         break;
 132
 133                 cpu_relax();
 134         }
 135
 136         if (!start) {
 137                 /* Stop the dot clock. */
 138                 lcdc_write(sdev, LDDCKSTPR, LDDCKSTPR_DCKSTP);
 139         }
 140 }
 141
 142 /*
 143  * shmob_drm_crtc_start - Configure and start the LCDC
 144  * @scrtc: the SH Mobile CRTC
 145  *
 146  * Configure and start the LCDC device. External devices (clocks, MERAM, panels,
 147  * ...) are not touched by this function.
 148  */
 149 static void shmob_drm_crtc_start(struct shmob_drm_crtc *scrtc)
 150 {
 151         struct drm_crtc *crtc = &scrtc->crtc;
 152         struct shmob_drm_device *sdev = crtc->dev->dev_private;
 153         const struct shmob_drm_interface_data *idata = &sdev->pdata->iface;
 154         const struct shmob_drm_format_info *format;
 155         struct drm_device *dev = sdev->ddev;
 156         struct drm_plane *plane;
 157         u32 value;
 158         int ret;
 159
 160         if (scrtc->started)
 161                 return;
 162
 163         format = shmob_drm_format_info(crtc->primary->fb->format->format);
 164         if (WARN_ON(format == NULL))
 165                 return;
 166
 167         /* Enable clocks before accessing the hardware. */
 168         ret = shmob_drm_clk_on(sdev);
 169         if (ret < 0)
 170                 return;
 171
 172         /* Reset and enable the LCDC. */
 173         lcdc_write(sdev, LDCNT2R, lcdc_read(sdev, LDCNT2R) | LDCNT2R_BR);
 174         lcdc_wait_bit(sdev, LDCNT2R, LDCNT2R_BR, 0);
 175         lcdc_write(sdev, LDCNT2R, LDCNT2R_ME);
 176
 177         /* Stop the LCDC first and disable all interrupts. */
 178         shmob_drm_crtc_start_stop(scrtc, false);
 179         lcdc_write(sdev, LDINTR, 0);
 180
 181         /* Configure power supply, dot clocks and start them. */
 182         lcdc_write(sdev, LDPMR, 0);
 183
 184         value = sdev->lddckr;
 185         if (idata->clk_div) {
 186                 /* FIXME: sh7724 can only use 42, 48, 54 and 60 for the divider
 187                  * denominator.
 188                  */
 189                 lcdc_write(sdev, LDDCKPAT1R, 0);
 190                 lcdc_write(sdev, LDDCKPAT2R, (1 << (idata->clk_div / 2)) - 1);
 191
 192                 if (idata->clk_div == 1)
 193                         value |= LDDCKR_MOSEL;
 194                 else
 195                         value |= idata->clk_div;
 196         }
 197
 198         lcdc_write(sdev, LDDCKR, value);
 199         lcdc_write(sdev, LDDCKSTPR, 0);
 200         lcdc_wait_bit(sdev, LDDCKSTPR, ~0, 0);
 201
 202         /* TODO: Setup SYS panel */
 203
 204         /* Setup geometry, format, frame buffer memory and operation mode. */
 205         shmob_drm_crtc_setup_geometry(scrtc);
 206
 207         /* TODO: Handle YUV colorspaces. Hardcode REC709 for now. */
 208         lcdc_write(sdev, LDDFR, format->lddfr | LDDFR_CF1);
 209         lcdc_write(sdev, LDMLSR, scrtc->line_size);
 210         lcdc_write(sdev, LDSA1R, scrtc->dma[0]);
 211         if (format->yuv)
 212                 lcdc_write(sdev, LDSA2R, scrtc->dma[1]);
 213         lcdc_write(sdev, LDSM1R, 0);
 214
 215         /* Word and long word swap. */
 216         switch (format->fourcc) {
 217         case DRM_FORMAT_RGB565:
 218         case DRM_FORMAT_NV21:
 219         case DRM_FORMAT_NV61:
 220         case DRM_FORMAT_NV42:
 221                 value = LDDDSR_LS | LDDDSR_WS;
 222                 break;
 223         case DRM_FORMAT_RGB888:
 224         case DRM_FORMAT_NV12:
 225         case DRM_FORMAT_NV16:
 226         case DRM_FORMAT_NV24:
 227                 value = LDDDSR_LS | LDDDSR_WS | LDDDSR_BS;
 228                 break;
 229         case DRM_FORMAT_ARGB8888:
 230         default:
 231                 value = LDDDSR_LS;
 232                 break;
 233         }
 234         lcdc_write(sdev, LDDDSR, value);
 235
 236         /* Setup planes. */
 237         drm_for_each_legacy_plane(plane, dev) {
 238                 if (plane->crtc == crtc)
 239                         shmob_drm_plane_setup(plane);
 240         }
 241
 242         /* Enable the display output. */
 243         lcdc_write(sdev, LDCNT1R, LDCNT1R_DE);
 244
 245         shmob_drm_crtc_start_stop(scrtc, true);
 246
 247         scrtc->started = true;
 248 }
 249
 250 static void shmob_drm_crtc_stop(struct shmob_drm_crtc *scrtc)
 251 {
 252         struct drm_crtc *crtc = &scrtc->crtc;
 253         struct shmob_drm_device *sdev = crtc->dev->dev_private;
 254
 255         if (!scrtc->started)
 256                 return;
 257
 258         /* Stop the LCDC. */
 259         shmob_drm_crtc_start_stop(scrtc, false);
 260
 261         /* Disable the display output. */
 262         lcdc_write(sdev, LDCNT1R, 0);
 263
 264         /* Stop clocks. */
 265         shmob_drm_clk_off(sdev);
 266
 267         scrtc->started = false;
 268 }
 269
 270 void shmob_drm_crtc_suspend(struct shmob_drm_crtc *scrtc)
 271 {
 272         shmob_drm_crtc_stop(scrtc);
 273 }
 274
 275 void shmob_drm_crtc_resume(struct shmob_drm_crtc *scrtc)
 276 {
 277         if (scrtc->dpms != DRM_MODE_DPMS_ON)
 278                 return;
 279
 280         shmob_drm_crtc_start(scrtc);
 281 }
 282
 283 static void shmob_drm_crtc_compute_base(struct shmob_drm_crtc *scrtc,
 284                                         int x, int y)
 285 {
 286         struct drm_crtc *crtc = &scrtc->crtc;
 287         struct drm_framebuffer *fb = crtc->primary->fb;
 288         struct drm_gem_cma_object *gem;
 289         unsigned int bpp;
 290
 291         bpp = scrtc->format->yuv ? 8 : scrtc->format->bpp;
 292         gem = drm_fb_cma_get_gem_obj(fb, 0);
 293         scrtc->dma[0] = gem->paddr + fb->offsets[0]
 294                       + y * fb->pitches[0] + x * bpp / 8;
 295
 296         if (scrtc->format->yuv) {
 297                 bpp = scrtc->format->bpp - 8;
 298                 gem = drm_fb_cma_get_gem_obj(fb, 1);
 299                 scrtc->dma[1] = gem->paddr + fb->offsets[1]
 300                               + y / (bpp == 4 ? 2 : 1) * fb->pitches[1]
 301                               + x * (bpp == 16 ? 2 : 1);
 302         }
 303 }
 304
 305 static void shmob_drm_crtc_update_base(struct shmob_drm_crtc *scrtc)
 306 {
 307         struct drm_crtc *crtc = &scrtc->crtc;
 308         struct shmob_drm_device *sdev = crtc->dev->dev_private;
 309
 310         shmob_drm_crtc_compute_base(scrtc, crtc->x, crtc->y);
 311
 312         lcdc_write_mirror(sdev, LDSA1R, scrtc->dma[0]);
 313         if (scrtc->format->yuv)
 314                 lcdc_write_mirror(sdev, LDSA2R, scrtc->dma[1]);
 315
 316         lcdc_write(sdev, LDRCNTR, lcdc_read(sdev, LDRCNTR) ^ LDRCNTR_MRS);
 317 }
 318
 319 #define to_shmob_crtc(c)        container_of(c, struct shmob_drm_crtc, crtc)
 320
 321 static void shmob_drm_crtc_dpms(struct drm_crtc *crtc, int mode)
 322 {
 323         struct shmob_drm_crtc *scrtc = to_shmob_crtc(crtc);
 324
 325         if (scrtc->dpms == mode)
 326                 return;
 327
 328         if (mode == DRM_MODE_DPMS_ON)
 329                 shmob_drm_crtc_start(scrtc);
 330         else
 331                 shmob_drm_crtc_stop(scrtc);
 332
 333         scrtc->dpms = mode;
 334 }
 335
 336 static void shmob_drm_crtc_mode_prepare(struct drm_crtc *crtc)
 337 {
 338         shmob_drm_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
 339 }
 340
 341 static int shmob_drm_crtc_mode_set(struct drm_crtc *crtc,
 342                                    struct drm_display_mode *mode,
 343                                    struct drm_display_mode *adjusted_mode,
 344                                    int x, int y,
 345                                    struct drm_framebuffer *old_fb)
 346 {
 347         struct shmob_drm_crtc *scrtc = to_shmob_crtc(crtc);
 348         struct shmob_drm_device *sdev = crtc->dev->dev_private;
 349         const struct shmob_drm_format_info *format;
 350
 351         format = shmob_drm_format_info(crtc->primary->fb->format->format);
 352         if (format == NULL) {
 353                 dev_dbg(sdev->dev, "mode_set: unsupported format %08x\n",
 354                         crtc->primary->fb->format->format);
 355                 return -EINVAL;
 356         }
 357
 358         scrtc->format = format;
 359         scrtc->line_size = crtc->primary->fb->pitches[0];
 360
 361         shmob_drm_crtc_compute_base(scrtc, x, y);
 362
 363         return 0;
 364 }
 365
 366 static void shmob_drm_crtc_mode_commit(struct drm_crtc *crtc)
 367 {
 368         shmob_drm_crtc_dpms(crtc, DRM_MODE_DPMS_ON);
 369 }
 370
 371 static int shmob_drm_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
 372                                         struct drm_framebuffer *old_fb)
 373 {
 374         shmob_drm_crtc_update_base(to_shmob_crtc(crtc));
 375
 376         return 0;
 377 }
 378
 379 static const struct drm_crtc_helper_funcs crtc_helper_funcs = {
 380         .dpms = shmob_drm_crtc_dpms,
 381         .prepare = shmob_drm_crtc_mode_prepare,
 382         .commit = shmob_drm_crtc_mode_commit,
 383         .mode_set = shmob_drm_crtc_mode_set,
 384         .mode_set_base = shmob_drm_crtc_mode_set_base,
 385 };
 386
 387 void shmob_drm_crtc_finish_page_flip(struct shmob_drm_crtc *scrtc)
 388 {
 389         struct drm_pending_vblank_event *event;
 390         struct drm_device *dev = scrtc->crtc.dev;
 391         unsigned long flags;
 392
 393         spin_lock_irqsave(&dev->event_lock, flags);
 394         event = scrtc->event;
 395         scrtc->event = NULL;
 396         if (event) {
 397                 drm_crtc_send_vblank_event(&scrtc->crtc, event);
 398                 drm_crtc_vblank_put(&scrtc->crtc);
 399         }
 400         spin_unlock_irqrestore(&dev->event_lock, flags);
 401 }
 402
 403 static int shmob_drm_crtc_page_flip(struct drm_crtc *crtc,
 404                                     struct drm_framebuffer *fb,
 405                                     struct drm_pending_vblank_event *event,
 406                                     uint32_t page_flip_flags,
 407                                     struct drm_modeset_acquire_ctx *ctx)
 408 {
 409         struct shmob_drm_crtc *scrtc = to_shmob_crtc(crtc);
 410         struct drm_device *dev = scrtc->crtc.dev;
 411         unsigned long flags;
 412
 413         spin_lock_irqsave(&dev->event_lock, flags);
 414         if (scrtc->event != NULL) {
 415                 spin_unlock_irqrestore(&dev->event_lock, flags);
 416                 return -EBUSY;
 417         }
 418         spin_unlock_irqrestore(&dev->event_lock, flags);
 419
 420         crtc->primary->fb = fb;
 421         shmob_drm_crtc_update_base(scrtc);
 422
 423         if (event) {
 424                 event->pipe = 0;
 425                 drm_crtc_vblank_get(&scrtc->crtc);
 426                 spin_lock_irqsave(&dev->event_lock, flags);
 427                 scrtc->event = event;
 428                 spin_unlock_irqrestore(&dev->event_lock, flags);
 429         }
 430
 431         return 0;
 432 }
 433
 434 static void shmob_drm_crtc_enable_vblank(struct shmob_drm_device *sdev,
 435                                          bool enable)
 436 {
 437         unsigned long flags;
 438         u32 ldintr;
 439
 440         /* Be careful not to acknowledge any pending interrupt. */
 441         spin_lock_irqsave(&sdev->irq_lock, flags);
 442         ldintr = lcdc_read(sdev, LDINTR) | LDINTR_STATUS_MASK;
 443         if (enable)
 444                 ldintr |= LDINTR_VEE;
 445         else
 446                 ldintr &= ~LDINTR_VEE;
 447         lcdc_write(sdev, LDINTR, ldintr);
 448         spin_unlock_irqrestore(&sdev->irq_lock, flags);
 449 }
 450
 451 static int shmob_drm_enable_vblank(struct drm_crtc *crtc)
 452 {
 453         struct shmob_drm_device *sdev = crtc->dev->dev_private;
 454
 455         shmob_drm_crtc_enable_vblank(sdev, true);
 456
 457         return 0;
 458 }
 459
 460 static void shmob_drm_disable_vblank(struct drm_crtc *crtc)
 461 {
 462         struct shmob_drm_device *sdev = crtc->dev->dev_private;
 463
 464         shmob_drm_crtc_enable_vblank(sdev, false);
 465 }
 466
 467 static const struct drm_crtc_funcs crtc_funcs = {
 468         .destroy = drm_crtc_cleanup,
 469         .set_config = drm_crtc_helper_set_config,
 470         .page_flip = shmob_drm_crtc_page_flip,
 471         .enable_vblank = shmob_drm_enable_vblank,
 472         .disable_vblank = shmob_drm_disable_vblank,
 473 };
 474
 475 int shmob_drm_crtc_create(struct shmob_drm_device *sdev)
 476 {
 477         struct drm_crtc *crtc = &sdev->crtc.crtc;
 478         int ret;
 479
 480         sdev->crtc.dpms = DRM_MODE_DPMS_OFF;
 481
 482         ret = drm_crtc_init(sdev->ddev, crtc, &crtc_funcs);
 483         if (ret < 0)
 484                 return ret;
 485
 486         drm_crtc_helper_add(crtc, &crtc_helper_funcs);
 487
 488         return 0;
 489 }
 490
 491 /* -----------------------------------------------------------------------------
 492  * Encoder
 493  */
 494
 495 #define to_shmob_encoder(e) \
 496         container_of(e, struct shmob_drm_encoder, encoder)
 497
 498 static void shmob_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
 499 {
 500         struct shmob_drm_encoder *senc = to_shmob_encoder(encoder);
 501         struct shmob_drm_device *sdev = encoder->dev->dev_private;
 502         struct shmob_drm_connector *scon = &sdev->connector;
 503
 504         if (senc->dpms == mode)
 505                 return;
 506
 507         shmob_drm_backlight_dpms(scon, mode);
 508
 509         senc->dpms = mode;
 510 }
 511
 512 static bool shmob_drm_encoder_mode_fixup(struct drm_encoder *encoder,
 513                                          const struct drm_display_mode *mode,
 514                                          struct drm_display_mode *adjusted_mode)
 515 {
 516         struct drm_device *dev = encoder->dev;
 517         struct shmob_drm_device *sdev = dev->dev_private;
 518         struct drm_connector *connector = &sdev->connector.connector;
 519         const struct drm_display_mode *panel_mode;
 520
 521         if (list_empty(&connector->modes)) {
 522                 dev_dbg(dev->dev, "mode_fixup: empty modes list\n");
 523                 return false;
 524         }
 525
 526         /* The flat panel mode is fixed, just copy it to the adjusted mode. */
 527         panel_mode = list_first_entry(&connector->modes,
 528                                       struct drm_display_mode, head);
 529         drm_mode_copy(adjusted_mode, panel_mode);
 530
 531         return true;
 532 }
 533
 534 static void shmob_drm_encoder_mode_prepare(struct drm_encoder *encoder)
 535 {
 536         /* No-op, everything is handled in the CRTC code. */
 537 }
 538
 539 static void shmob_drm_encoder_mode_set(struct drm_encoder *encoder,
 540                                        struct drm_display_mode *mode,
 541                                        struct drm_display_mode *adjusted_mode)
 542 {
 543         /* No-op, everything is handled in the CRTC code. */
 544 }
 545
 546 static void shmob_drm_encoder_mode_commit(struct drm_encoder *encoder)
 547 {
 548         /* No-op, everything is handled in the CRTC code. */
 549 }
 550
 551 static const struct drm_encoder_helper_funcs encoder_helper_funcs = {
 552         .dpms = shmob_drm_encoder_dpms,
 553         .mode_fixup = shmob_drm_encoder_mode_fixup,
 554         .prepare = shmob_drm_encoder_mode_prepare,
 555         .commit = shmob_drm_encoder_mode_commit,
 556         .mode_set = shmob_drm_encoder_mode_set,
 557 };
 558
 559 static void shmob_drm_encoder_destroy(struct drm_encoder *encoder)
 560 {
 561         drm_encoder_cleanup(encoder);
 562 }
 563
 564 static const struct drm_encoder_funcs encoder_funcs = {
 565         .destroy = shmob_drm_encoder_destroy,
 566 };
 567
 568 int shmob_drm_encoder_create(struct shmob_drm_device *sdev)
 569 {
 570         struct drm_encoder *encoder = &sdev->encoder.encoder;
 571         int ret;
 572
 573         sdev->encoder.dpms = DRM_MODE_DPMS_OFF;
 574
 575         encoder->possible_crtcs = 1;
 576
 577         ret = drm_encoder_init(sdev->ddev, encoder, &encoder_funcs,
 578                                DRM_MODE_ENCODER_LVDS, NULL);
 579         if (ret < 0)
 580                 return ret;
 581
 582         drm_encoder_helper_add(encoder, &encoder_helper_funcs);
 583
 584         return 0;
 585 }
 586
 587 /* -----------------------------------------------------------------------------
 588  * Connector
 589  */
 590
 591 #define to_shmob_connector(c) \
 592         container_of(c, struct shmob_drm_connector, connector)
 593
 594 static int shmob_drm_connector_get_modes(struct drm_connector *connector)
 595 {
 596         struct shmob_drm_device *sdev = connector->dev->dev_private;
 597         struct drm_display_mode *mode;
 598
 599         mode = drm_mode_create(connector->dev);
 600         if (mode == NULL)
 601                 return 0;
 602
 603         mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
 604         mode->clock = sdev->pdata->panel.mode.clock;
 605         mode->hdisplay = sdev->pdata->panel.mode.hdisplay;
 606         mode->hsync_start = sdev->pdata->panel.mode.hsync_start;
 607         mode->hsync_end = sdev->pdata->panel.mode.hsync_end;
 608         mode->htotal = sdev->pdata->panel.mode.htotal;
 609         mode->vdisplay = sdev->pdata->panel.mode.vdisplay;
 610         mode->vsync_start = sdev->pdata->panel.mode.vsync_start;
 611         mode->vsync_end = sdev->pdata->panel.mode.vsync_end;
 612         mode->vtotal = sdev->pdata->panel.mode.vtotal;
 613         mode->flags = sdev->pdata->panel.mode.flags;
 614
 615         drm_mode_set_name(mode);
 616         drm_mode_probed_add(connector, mode);
 617
 618         connector->display_info.width_mm = sdev->pdata->panel.width_mm;
 619         connector->display_info.height_mm = sdev->pdata->panel.height_mm;
 620
 621         return 1;
 622 }
 623
 624 static struct drm_encoder *
 625 shmob_drm_connector_best_encoder(struct drm_connector *connector)
 626 {
 627         struct shmob_drm_connector *scon = to_shmob_connector(connector);
 628
 629         return scon->encoder;
 630 }
 631
 632 static const struct drm_connector_helper_funcs connector_helper_funcs = {
 633         .get_modes = shmob_drm_connector_get_modes,
 634         .best_encoder = shmob_drm_connector_best_encoder,
 635 };
 636
 637 static void shmob_drm_connector_destroy(struct drm_connector *connector)
 638 {
 639         struct shmob_drm_connector *scon = to_shmob_connector(connector);
 640
 641         shmob_drm_backlight_exit(scon);
 642         drm_connector_unregister(connector);
 643         drm_connector_cleanup(connector);
 644 }
 645
 646 static const struct drm_connector_funcs connector_funcs = {
 647         .dpms = drm_helper_connector_dpms,
 648         .fill_modes = drm_helper_probe_single_connector_modes,
 649         .destroy = shmob_drm_connector_destroy,
 650 };
 651
 652 int shmob_drm_connector_create(struct shmob_drm_device *sdev,
 653                                struct drm_encoder *encoder)
 654 {
 655         struct drm_connector *connector = &sdev->connector.connector;
 656         int ret;
 657
 658         sdev->connector.encoder = encoder;
 659
 660         connector->display_info.width_mm = sdev->pdata->panel.width_mm;
 661         connector->display_info.height_mm = sdev->pdata->panel.height_mm;
 662
 663         ret = drm_connector_init(sdev->ddev, connector, &connector_funcs,
 664                                  DRM_MODE_CONNECTOR_LVDS);
 665         if (ret < 0)
 666                 return ret;
 667
 668         drm_connector_helper_add(connector, &connector_helper_funcs);
 669
 670         ret = shmob_drm_backlight_init(&sdev->connector);
 671         if (ret < 0)
 672                 goto err_cleanup;
 673
 674         ret = drm_connector_attach_encoder(connector, encoder);
 675         if (ret < 0)
 676                 goto err_backlight;
 677
 678         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
 679         drm_object_property_set_value(&connector->base,
 680                 sdev->ddev->mode_config.dpms_property, DRM_MODE_DPMS_OFF);
 681
 682         return 0;
 683
 684 err_backlight:
 685         shmob_drm_backlight_exit(&sdev->connector);
 686 err_cleanup:
 687         drm_connector_cleanup(connector);
 688         return ret;
 689 }