drivers/gpu/drm/tiny/simpledrm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/clk.h>
   4 #include <linux/of_clk.h>
   5 #include <linux/minmax.h>
   6 #include <linux/of_address.h>
   7 #include <linux/platform_data/simplefb.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/regulator/consumer.h>
  10
  11 #include <drm/drm_aperture.h>
  12 #include <drm/drm_atomic.h>
  13 #include <drm/drm_atomic_state_helper.h>
  14 #include <drm/drm_connector.h>
  15 #include <drm/drm_crtc_helper.h>
  16 #include <drm/drm_damage_helper.h>
  17 #include <drm/drm_device.h>
  18 #include <drm/drm_drv.h>
  19 #include <drm/drm_fbdev_generic.h>
  20 #include <drm/drm_format_helper.h>
  21 #include <drm/drm_gem_atomic_helper.h>
  22 #include <drm/drm_gem_framebuffer_helper.h>
  23 #include <drm/drm_gem_shmem_helper.h>
  24 #include <drm/drm_managed.h>
  25 #include <drm/drm_modeset_helper_vtables.h>
  26 #include <drm/drm_plane_helper.h>
  27 #include <drm/drm_probe_helper.h>
  28
  29 #define DRIVER_NAME     "simpledrm"
  30 #define DRIVER_DESC     "DRM driver for simple-framebuffer platform devices"
  31 #define DRIVER_DATE     "20200625"
  32 #define DRIVER_MAJOR    1
  33 #define DRIVER_MINOR    0
  34
  35 /*
  36  * Helpers for simplefb
  37  */
  38
  39 static int
  40 simplefb_get_validated_int(struct drm_device *dev, const char *name,
  41                            uint32_t value)
  42 {
  43         if (value > INT_MAX) {
  44                 drm_err(dev, "simplefb: invalid framebuffer %s of %u\n",
  45                         name, value);
  46                 return -EINVAL;
  47         }
  48         return (int)value;
  49 }
  50
  51 static int
  52 simplefb_get_validated_int0(struct drm_device *dev, const char *name,
  53                             uint32_t value)
  54 {
  55         if (!value) {
  56                 drm_err(dev, "simplefb: invalid framebuffer %s of %u\n",
  57                         name, value);
  58                 return -EINVAL;
  59         }
  60         return simplefb_get_validated_int(dev, name, value);
  61 }
  62
  63 static const struct drm_format_info *
  64 simplefb_get_validated_format(struct drm_device *dev, const char *format_name)
  65 {
  66         static const struct simplefb_format formats[] = SIMPLEFB_FORMATS;
  67         const struct simplefb_format *fmt = formats;
  68         const struct simplefb_format *end = fmt + ARRAY_SIZE(formats);
  69         const struct drm_format_info *info;
  70
  71         if (!format_name) {
  72                 drm_err(dev, "simplefb: missing framebuffer format\n");
  73                 return ERR_PTR(-EINVAL);
  74         }
  75
  76         while (fmt < end) {
  77                 if (!strcmp(format_name, fmt->name)) {
  78                         info = drm_format_info(fmt->fourcc);
  79                         if (!info)
  80                                 return ERR_PTR(-EINVAL);
  81                         return info;
  82                 }
  83                 ++fmt;
  84         }
  85
  86         drm_err(dev, "simplefb: unknown framebuffer format %s\n",
  87                 format_name);
  88
  89         return ERR_PTR(-EINVAL);
  90 }
  91
  92 static int
  93 simplefb_get_width_pd(struct drm_device *dev,
  94                       const struct simplefb_platform_data *pd)
  95 {
  96         return simplefb_get_validated_int0(dev, "width", pd->width);
  97 }
  98
  99 static int
 100 simplefb_get_height_pd(struct drm_device *dev,
 101                        const struct simplefb_platform_data *pd)
 102 {
 103         return simplefb_get_validated_int0(dev, "height", pd->height);
 104 }
 105
 106 static int
 107 simplefb_get_stride_pd(struct drm_device *dev,
 108                        const struct simplefb_platform_data *pd)
 109 {
 110         return simplefb_get_validated_int(dev, "stride", pd->stride);
 111 }
 112
 113 static const struct drm_format_info *
 114 simplefb_get_format_pd(struct drm_device *dev,
 115                        const struct simplefb_platform_data *pd)
 116 {
 117         return simplefb_get_validated_format(dev, pd->format);
 118 }
 119
 120 static int
 121 simplefb_read_u32_of(struct drm_device *dev, struct device_node *of_node,
 122                      const char *name, u32 *value)
 123 {
 124         int ret = of_property_read_u32(of_node, name, value);
 125
 126         if (ret)
 127                 drm_err(dev, "simplefb: cannot parse framebuffer %s: error %d\n",
 128                         name, ret);
 129         return ret;
 130 }
 131
 132 static int
 133 simplefb_read_string_of(struct drm_device *dev, struct device_node *of_node,
 134                         const char *name, const char **value)
 135 {
 136         int ret = of_property_read_string(of_node, name, value);
 137
 138         if (ret)
 139                 drm_err(dev, "simplefb: cannot parse framebuffer %s: error %d\n",
 140                         name, ret);
 141         return ret;
 142 }
 143
 144 static int
 145 simplefb_get_width_of(struct drm_device *dev, struct device_node *of_node)
 146 {
 147         u32 width;
 148         int ret = simplefb_read_u32_of(dev, of_node, "width", &width);
 149
 150         if (ret)
 151                 return ret;
 152         return simplefb_get_validated_int0(dev, "width", width);
 153 }
 154
 155 static int
 156 simplefb_get_height_of(struct drm_device *dev, struct device_node *of_node)
 157 {
 158         u32 height;
 159         int ret = simplefb_read_u32_of(dev, of_node, "height", &height);
 160
 161         if (ret)
 162                 return ret;
 163         return simplefb_get_validated_int0(dev, "height", height);
 164 }
 165
 166 static int
 167 simplefb_get_stride_of(struct drm_device *dev, struct device_node *of_node)
 168 {
 169         u32 stride;
 170         int ret = simplefb_read_u32_of(dev, of_node, "stride", &stride);
 171
 172         if (ret)
 173                 return ret;
 174         return simplefb_get_validated_int(dev, "stride", stride);
 175 }
 176
 177 static const struct drm_format_info *
 178 simplefb_get_format_of(struct drm_device *dev, struct device_node *of_node)
 179 {
 180         const char *format;
 181         int ret = simplefb_read_string_of(dev, of_node, "format", &format);
 182
 183         if (ret)
 184                 return ERR_PTR(ret);
 185         return simplefb_get_validated_format(dev, format);
 186 }
 187
 188 static struct resource *
 189 simplefb_get_memory_of(struct drm_device *dev, struct device_node *of_node)
 190 {
 191         struct device_node *np;
 192         struct resource *res;
 193         int err;
 194
 195         np = of_parse_phandle(of_node, "memory-region", 0);
 196         if (!np)
 197                 return NULL;
 198
 199         res = devm_kzalloc(dev->dev, sizeof(*res), GFP_KERNEL);
 200         if (!res)
 201                 return ERR_PTR(-ENOMEM);
 202
 203         err = of_address_to_resource(np, 0, res);
 204         if (err)
 205                 return ERR_PTR(err);
 206
 207         if (of_property_present(of_node, "reg"))
 208                 drm_warn(dev, "preferring \"memory-region\" over \"reg\" property\n");
 209
 210         return res;
 211 }
 212
 213 /*
 214  * Simple Framebuffer device
 215  */
 216
 217 struct simpledrm_device {
 218         struct drm_device dev;
 219
 220         /* clocks */
 221 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
 222         unsigned int clk_count;
 223         struct clk **clks;
 224 #endif
 225         /* regulators */
 226 #if defined CONFIG_OF && defined CONFIG_REGULATOR
 227         unsigned int regulator_count;
 228         struct regulator **regulators;
 229 #endif
 230
 231         /* simplefb settings */
 232         struct drm_display_mode mode;
 233         const struct drm_format_info *format;
 234         unsigned int pitch;
 235
 236         /* memory management */
 237         struct iosys_map screen_base;
 238
 239         /* modesetting */
 240         uint32_t formats[8];
 241         size_t nformats;
 242         struct drm_plane primary_plane;
 243         struct drm_crtc crtc;
 244         struct drm_encoder encoder;
 245         struct drm_connector connector;
 246 };
 247
 248 static struct simpledrm_device *simpledrm_device_of_dev(struct drm_device *dev)
 249 {
 250         return container_of(dev, struct simpledrm_device, dev);
 251 }
 252
 253 /*
 254  * Hardware
 255  */
 256
 257 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
 258 /*
 259  * Clock handling code.
 260  *
 261  * Here we handle the clocks property of our "simple-framebuffer" dt node.
 262  * This is necessary so that we can make sure that any clocks needed by
 263  * the display engine that the bootloader set up for us (and for which it
 264  * provided a simplefb dt node), stay up, for the life of the simplefb
 265  * driver.
 266  *
 267  * When the driver unloads, we cleanly disable, and then release the clocks.
 268  *
 269  * We only complain about errors here, no action is taken as the most likely
 270  * error can only happen due to a mismatch between the bootloader which set
 271  * up simplefb, and the clock definitions in the device tree. Chances are
 272  * that there are no adverse effects, and if there are, a clean teardown of
 273  * the fb probe will not help us much either. So just complain and carry on,
 274  * and hope that the user actually gets a working fb at the end of things.
 275  */
 276
 277 static void simpledrm_device_release_clocks(void *res)
 278 {
 279         struct simpledrm_device *sdev = simpledrm_device_of_dev(res);
 280         unsigned int i;
 281
 282         for (i = 0; i < sdev->clk_count; ++i) {
 283                 if (sdev->clks[i]) {
 284                         clk_disable_unprepare(sdev->clks[i]);
 285                         clk_put(sdev->clks[i]);
 286                 }
 287         }
 288 }
 289
 290 static int simpledrm_device_init_clocks(struct simpledrm_device *sdev)
 291 {
 292         struct drm_device *dev = &sdev->dev;
 293         struct platform_device *pdev = to_platform_device(dev->dev);
 294         struct device_node *of_node = pdev->dev.of_node;
 295         struct clk *clock;
 296         unsigned int i;
 297         int ret;
 298
 299         if (dev_get_platdata(&pdev->dev) || !of_node)
 300                 return 0;
 301
 302         sdev->clk_count = of_clk_get_parent_count(of_node);
 303         if (!sdev->clk_count)
 304                 return 0;
 305
 306         sdev->clks = drmm_kzalloc(dev, sdev->clk_count * sizeof(sdev->clks[0]),
 307                                   GFP_KERNEL);
 308         if (!sdev->clks)
 309                 return -ENOMEM;
 310
 311         for (i = 0; i < sdev->clk_count; ++i) {
 312                 clock = of_clk_get(of_node, i);
 313                 if (IS_ERR(clock)) {
 314                         ret = PTR_ERR(clock);
 315                         if (ret == -EPROBE_DEFER)
 316                                 goto err;
 317                         drm_err(dev, "clock %u not found: %d\n", i, ret);
 318                         continue;
 319                 }
 320                 ret = clk_prepare_enable(clock);
 321                 if (ret) {
 322                         drm_err(dev, "failed to enable clock %u: %d\n",
 323                                 i, ret);
 324                         clk_put(clock);
 325                         continue;
 326                 }
 327                 sdev->clks[i] = clock;
 328         }
 329
 330         return devm_add_action_or_reset(&pdev->dev,
 331                                         simpledrm_device_release_clocks,
 332                                         sdev);
 333
 334 err:
 335         while (i) {
 336                 --i;
 337                 if (sdev->clks[i]) {
 338                         clk_disable_unprepare(sdev->clks[i]);
 339                         clk_put(sdev->clks[i]);
 340                 }
 341         }
 342         return ret;
 343 }
 344 #else
 345 static int simpledrm_device_init_clocks(struct simpledrm_device *sdev)
 346 {
 347         return 0;
 348 }
 349 #endif
 350
 351 #if defined CONFIG_OF && defined CONFIG_REGULATOR
 352
 353 #define SUPPLY_SUFFIX "-supply"
 354
 355 /*
 356  * Regulator handling code.
 357  *
 358  * Here we handle the num-supplies and vin*-supply properties of our
 359  * "simple-framebuffer" dt node. This is necessary so that we can make sure
 360  * that any regulators needed by the display hardware that the bootloader
 361  * set up for us (and for which it provided a simplefb dt node), stay up,
 362  * for the life of the simplefb driver.
 363  *
 364  * When the driver unloads, we cleanly disable, and then release the
 365  * regulators.
 366  *
 367  * We only complain about errors here, no action is taken as the most likely
 368  * error can only happen due to a mismatch between the bootloader which set
 369  * up simplefb, and the regulator definitions in the device tree. Chances are
 370  * that there are no adverse effects, and if there are, a clean teardown of
 371  * the fb probe will not help us much either. So just complain and carry on,
 372  * and hope that the user actually gets a working fb at the end of things.
 373  */
 374
 375 static void simpledrm_device_release_regulators(void *res)
 376 {
 377         struct simpledrm_device *sdev = simpledrm_device_of_dev(res);
 378         unsigned int i;
 379
 380         for (i = 0; i < sdev->regulator_count; ++i) {
 381                 if (sdev->regulators[i]) {
 382                         regulator_disable(sdev->regulators[i]);
 383                         regulator_put(sdev->regulators[i]);
 384                 }
 385         }
 386 }
 387
 388 static int simpledrm_device_init_regulators(struct simpledrm_device *sdev)
 389 {
 390         struct drm_device *dev = &sdev->dev;
 391         struct platform_device *pdev = to_platform_device(dev->dev);
 392         struct device_node *of_node = pdev->dev.of_node;
 393         struct property *prop;
 394         struct regulator *regulator;
 395         const char *p;
 396         unsigned int count = 0, i = 0;
 397         int ret;
 398
 399         if (dev_get_platdata(&pdev->dev) || !of_node)
 400                 return 0;
 401
 402         /* Count the number of regulator supplies */
 403         for_each_property_of_node(of_node, prop) {
 404                 p = strstr(prop->name, SUPPLY_SUFFIX);
 405                 if (p && p != prop->name)
 406                         ++count;
 407         }
 408
 409         if (!count)
 410                 return 0;
 411
 412         sdev->regulators = drmm_kzalloc(dev,
 413                                         count * sizeof(sdev->regulators[0]),
 414                                         GFP_KERNEL);
 415         if (!sdev->regulators)
 416                 return -ENOMEM;
 417
 418         for_each_property_of_node(of_node, prop) {
 419                 char name[32]; /* 32 is max size of property name */
 420                 size_t len;
 421
 422                 p = strstr(prop->name, SUPPLY_SUFFIX);
 423                 if (!p || p == prop->name)
 424                         continue;
 425                 len = strlen(prop->name) - strlen(SUPPLY_SUFFIX) + 1;
 426                 strscpy(name, prop->name, min(sizeof(name), len));
 427
 428                 regulator = regulator_get_optional(&pdev->dev, name);
 429                 if (IS_ERR(regulator)) {
 430                         ret = PTR_ERR(regulator);
 431                         if (ret == -EPROBE_DEFER)
 432                                 goto err;
 433                         drm_err(dev, "regulator %s not found: %d\n",
 434                                 name, ret);
 435                         continue;
 436                 }
 437
 438                 ret = regulator_enable(regulator);
 439                 if (ret) {
 440                         drm_err(dev, "failed to enable regulator %u: %d\n",
 441                                 i, ret);
 442                         regulator_put(regulator);
 443                         continue;
 444                 }
 445
 446                 sdev->regulators[i++] = regulator;
 447         }
 448         sdev->regulator_count = i;
 449
 450         return devm_add_action_or_reset(&pdev->dev,
 451                                         simpledrm_device_release_regulators,
 452                                         sdev);
 453
 454 err:
 455         while (i) {
 456                 --i;
 457                 if (sdev->regulators[i]) {
 458                         regulator_disable(sdev->regulators[i]);
 459                         regulator_put(sdev->regulators[i]);
 460                 }
 461         }
 462         return ret;
 463 }
 464 #else
 465 static int simpledrm_device_init_regulators(struct simpledrm_device *sdev)
 466 {
 467         return 0;
 468 }
 469 #endif
 470
 471 /*
 472  * Modesetting
 473  */
 474
 475 static const uint64_t simpledrm_primary_plane_format_modifiers[] = {
 476         DRM_FORMAT_MOD_LINEAR,
 477         DRM_FORMAT_MOD_INVALID
 478 };
 479
 480 static void simpledrm_primary_plane_helper_atomic_update(struct drm_plane *plane,
 481                                                          struct drm_atomic_state *state)
 482 {
 483         struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
 484         struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
 485         struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
 486         struct drm_framebuffer *fb = plane_state->fb;
 487         struct drm_device *dev = plane->dev;
 488         struct simpledrm_device *sdev = simpledrm_device_of_dev(dev);
 489         struct drm_atomic_helper_damage_iter iter;
 490         struct drm_rect damage;
 491         int ret, idx;
 492
 493         ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
 494         if (ret)
 495                 return;
 496
 497         if (!drm_dev_enter(dev, &idx))
 498                 goto out_drm_gem_fb_end_cpu_access;
 499
 500         drm_atomic_helper_damage_iter_init(&iter, old_plane_state, plane_state);
 501         drm_atomic_for_each_plane_damage(&iter, &damage) {
 502                 struct drm_rect dst_clip = plane_state->dst;
 503                 struct iosys_map dst = sdev->screen_base;
 504
 505                 if (!drm_rect_intersect(&dst_clip, &damage))
 506                         continue;
 507
 508                 iosys_map_incr(&dst, drm_fb_clip_offset(sdev->pitch, sdev->format, &dst_clip));
 509                 drm_fb_blit(&dst, &sdev->pitch, sdev->format->format, shadow_plane_state->data,
 510                             fb, &damage);
 511         }
 512
 513         drm_dev_exit(idx);
 514 out_drm_gem_fb_end_cpu_access:
 515         drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
 516 }
 517
 518 static void simpledrm_primary_plane_helper_atomic_disable(struct drm_plane *plane,
 519                                                           struct drm_atomic_state *state)
 520 {
 521         struct drm_device *dev = plane->dev;
 522         struct simpledrm_device *sdev = simpledrm_device_of_dev(dev);
 523         int idx;
 524
 525         if (!drm_dev_enter(dev, &idx))
 526                 return;
 527
 528         /* Clear screen to black if disabled */
 529         iosys_map_memset(&sdev->screen_base, 0, 0, sdev->pitch * sdev->mode.vdisplay);
 530
 531         drm_dev_exit(idx);
 532 }
 533
 534 static const struct drm_plane_helper_funcs simpledrm_primary_plane_helper_funcs = {
 535         DRM_GEM_SHADOW_PLANE_HELPER_FUNCS,
 536         .atomic_check = drm_plane_helper_atomic_check,
 537         .atomic_update = simpledrm_primary_plane_helper_atomic_update,
 538         .atomic_disable = simpledrm_primary_plane_helper_atomic_disable,
 539 };
 540
 541 static const struct drm_plane_funcs simpledrm_primary_plane_funcs = {
 542         .update_plane = drm_atomic_helper_update_plane,
 543         .disable_plane = drm_atomic_helper_disable_plane,
 544         .destroy = drm_plane_cleanup,
 545         DRM_GEM_SHADOW_PLANE_FUNCS,
 546 };
 547
 548 static enum drm_mode_status simpledrm_crtc_helper_mode_valid(struct drm_crtc *crtc,
 549                                                              const struct drm_display_mode *mode)
 550 {
 551         struct simpledrm_device *sdev = simpledrm_device_of_dev(crtc->dev);
 552
 553         return drm_crtc_helper_mode_valid_fixed(crtc, mode, &sdev->mode);
 554 }
 555
 556 /*
 557  * The CRTC is always enabled. Screen updates are performed by
 558  * the primary plane's atomic_update function. Disabling clears
 559  * the screen in the primary plane's atomic_disable function.
 560  */
 561 static const struct drm_crtc_helper_funcs simpledrm_crtc_helper_funcs = {
 562         .mode_valid = simpledrm_crtc_helper_mode_valid,
 563         .atomic_check = drm_crtc_helper_atomic_check,
 564 };
 565
 566 static const struct drm_crtc_funcs simpledrm_crtc_funcs = {
 567         .reset = drm_atomic_helper_crtc_reset,
 568         .destroy = drm_crtc_cleanup,
 569         .set_config = drm_atomic_helper_set_config,
 570         .page_flip = drm_atomic_helper_page_flip,
 571         .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
 572         .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
 573 };
 574
 575 static const struct drm_encoder_funcs simpledrm_encoder_funcs = {
 576         .destroy = drm_encoder_cleanup,
 577 };
 578
 579 static int simpledrm_connector_helper_get_modes(struct drm_connector *connector)
 580 {
 581         struct simpledrm_device *sdev = simpledrm_device_of_dev(connector->dev);
 582
 583         return drm_connector_helper_get_modes_fixed(connector, &sdev->mode);
 584 }
 585
 586 static const struct drm_connector_helper_funcs simpledrm_connector_helper_funcs = {
 587         .get_modes = simpledrm_connector_helper_get_modes,
 588 };
 589
 590 static const struct drm_connector_funcs simpledrm_connector_funcs = {
 591         .reset = drm_atomic_helper_connector_reset,
 592         .fill_modes = drm_helper_probe_single_connector_modes,
 593         .destroy = drm_connector_cleanup,
 594         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 595         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 596 };
 597
 598 static const struct drm_mode_config_funcs simpledrm_mode_config_funcs = {
 599         .fb_create = drm_gem_fb_create_with_dirty,
 600         .atomic_check = drm_atomic_helper_check,
 601         .atomic_commit = drm_atomic_helper_commit,
 602 };
 603
 604 /*
 605  * Init / Cleanup
 606  */
 607
 608 static struct drm_display_mode simpledrm_mode(unsigned int width,
 609                                               unsigned int height,
 610                                               unsigned int width_mm,
 611                                               unsigned int height_mm)
 612 {
 613         const struct drm_display_mode mode = {
 614                 DRM_MODE_INIT(60, width, height, width_mm, height_mm)
 615         };
 616
 617         return mode;
 618 }
 619
 620 static struct simpledrm_device *simpledrm_device_create(struct drm_driver *drv,
 621                                                         struct platform_device *pdev)
 622 {
 623         const struct simplefb_platform_data *pd = dev_get_platdata(&pdev->dev);
 624         struct device_node *of_node = pdev->dev.of_node;
 625         struct simpledrm_device *sdev;
 626         struct drm_device *dev;
 627         int width, height, stride;
 628         int width_mm = 0, height_mm = 0;
 629         struct device_node *panel_node;
 630         const struct drm_format_info *format;
 631         struct resource *res, *mem = NULL;
 632         struct drm_plane *primary_plane;
 633         struct drm_crtc *crtc;
 634         struct drm_encoder *encoder;
 635         struct drm_connector *connector;
 636         unsigned long max_width, max_height;
 637         size_t nformats;
 638         int ret;
 639
 640         sdev = devm_drm_dev_alloc(&pdev->dev, drv, struct simpledrm_device, dev);
 641         if (IS_ERR(sdev))
 642                 return ERR_CAST(sdev);
 643         dev = &sdev->dev;
 644         platform_set_drvdata(pdev, sdev);
 645
 646         /*
 647          * Hardware settings
 648          */
 649
 650         ret = simpledrm_device_init_clocks(sdev);
 651         if (ret)
 652                 return ERR_PTR(ret);
 653         ret = simpledrm_device_init_regulators(sdev);
 654         if (ret)
 655                 return ERR_PTR(ret);
 656
 657         if (pd) {
 658                 width = simplefb_get_width_pd(dev, pd);
 659                 if (width < 0)
 660                         return ERR_PTR(width);
 661                 height = simplefb_get_height_pd(dev, pd);
 662                 if (height < 0)
 663                         return ERR_PTR(height);
 664                 stride = simplefb_get_stride_pd(dev, pd);
 665                 if (stride < 0)
 666                         return ERR_PTR(stride);
 667                 format = simplefb_get_format_pd(dev, pd);
 668                 if (IS_ERR(format))
 669                         return ERR_CAST(format);
 670         } else if (of_node) {
 671                 width = simplefb_get_width_of(dev, of_node);
 672                 if (width < 0)
 673                         return ERR_PTR(width);
 674                 height = simplefb_get_height_of(dev, of_node);
 675                 if (height < 0)
 676                         return ERR_PTR(height);
 677                 stride = simplefb_get_stride_of(dev, of_node);
 678                 if (stride < 0)
 679                         return ERR_PTR(stride);
 680                 format = simplefb_get_format_of(dev, of_node);
 681                 if (IS_ERR(format))
 682                         return ERR_CAST(format);
 683                 mem = simplefb_get_memory_of(dev, of_node);
 684                 if (IS_ERR(mem))
 685                         return ERR_CAST(mem);
 686                 panel_node = of_parse_phandle(of_node, "panel", 0);
 687                 if (panel_node) {
 688                         simplefb_read_u32_of(dev, panel_node, "width-mm", &width_mm);
 689                         simplefb_read_u32_of(dev, panel_node, "height-mm", &height_mm);
 690                         of_node_put(panel_node);
 691                 }
 692         } else {
 693                 drm_err(dev, "no simplefb configuration found\n");
 694                 return ERR_PTR(-ENODEV);
 695         }
 696         if (!stride) {
 697                 stride = drm_format_info_min_pitch(format, 0, width);
 698                 if (drm_WARN_ON(dev, !stride))
 699                         return ERR_PTR(-EINVAL);
 700         }
 701
 702         /*
 703          * Assume a monitor resolution of 96 dpi if physical dimensions
 704          * are not specified to get a somewhat reasonable screen size.
 705          */
 706         if (!width_mm)
 707                 width_mm = DRM_MODE_RES_MM(width, 96ul);
 708         if (!height_mm)
 709                 height_mm = DRM_MODE_RES_MM(height, 96ul);
 710
 711         sdev->mode = simpledrm_mode(width, height, width_mm, height_mm);
 712         sdev->format = format;
 713         sdev->pitch = stride;
 714
 715         drm_dbg(dev, "display mode={" DRM_MODE_FMT "}\n", DRM_MODE_ARG(&sdev->mode));
 716         drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d byte\n",
 717                 &format->format, width, height, stride);
 718
 719         /*
 720          * Memory management
 721          */
 722
 723         if (mem) {
 724                 void *screen_base;
 725
 726                 ret = devm_aperture_acquire_from_firmware(dev, mem->start, resource_size(mem));
 727                 if (ret) {
 728                         drm_err(dev, "could not acquire memory range %pr: %d\n", mem, ret);
 729                         return ERR_PTR(ret);
 730                 }
 731
 732                 drm_dbg(dev, "using system memory framebuffer at %pr\n", mem);
 733
 734                 screen_base = devm_memremap(dev->dev, mem->start, resource_size(mem), MEMREMAP_WC);
 735                 if (IS_ERR(screen_base))
 736                         return screen_base;
 737
 738                 iosys_map_set_vaddr(&sdev->screen_base, screen_base);
 739         } else {
 740                 void __iomem *screen_base;
 741
 742                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 743                 if (!res)
 744                         return ERR_PTR(-EINVAL);
 745
 746                 ret = devm_aperture_acquire_from_firmware(dev, res->start, resource_size(res));
 747                 if (ret) {
 748                         drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret);
 749                         return ERR_PTR(ret);
 750                 }
 751
 752                 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res);
 753
 754                 mem = devm_request_mem_region(&pdev->dev, res->start, resource_size(res),
 755                                               drv->name);
 756                 if (!mem) {
 757                         /*
 758                          * We cannot make this fatal. Sometimes this comes from magic
 759                          * spaces our resource handlers simply don't know about. Use
 760                          * the I/O-memory resource as-is and try to map that instead.
 761                          */
 762                         drm_warn(dev, "could not acquire memory region %pr\n", res);
 763                         mem = res;
 764                 }
 765
 766                 screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem));
 767                 if (!screen_base)
 768                         return ERR_PTR(-ENOMEM);
 769
 770                 iosys_map_set_vaddr_iomem(&sdev->screen_base, screen_base);
 771         }
 772
 773         /*
 774          * Modesetting
 775          */
 776
 777         ret = drmm_mode_config_init(dev);
 778         if (ret)
 779                 return ERR_PTR(ret);
 780
 781         max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH);
 782         max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
 783
 784         dev->mode_config.min_width = width;
 785         dev->mode_config.max_width = max_width;
 786         dev->mode_config.min_height = height;
 787         dev->mode_config.max_height = max_height;
 788         dev->mode_config.preferred_depth = format->depth;
 789         dev->mode_config.funcs = &simpledrm_mode_config_funcs;
 790
 791         /* Primary plane */
 792
 793         nformats = drm_fb_build_fourcc_list(dev, &format->format, 1,
 794                                             sdev->formats, ARRAY_SIZE(sdev->formats));
 795
 796         primary_plane = &sdev->primary_plane;
 797         ret = drm_universal_plane_init(dev, primary_plane, 0, &simpledrm_primary_plane_funcs,
 798                                        sdev->formats, nformats,
 799                                        simpledrm_primary_plane_format_modifiers,
 800                                        DRM_PLANE_TYPE_PRIMARY, NULL);
 801         if (ret)
 802                 return ERR_PTR(ret);
 803         drm_plane_helper_add(primary_plane, &simpledrm_primary_plane_helper_funcs);
 804         drm_plane_enable_fb_damage_clips(primary_plane);
 805
 806         /* CRTC */
 807
 808         crtc = &sdev->crtc;
 809         ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL,
 810                                         &simpledrm_crtc_funcs, NULL);
 811         if (ret)
 812                 return ERR_PTR(ret);
 813         drm_crtc_helper_add(crtc, &simpledrm_crtc_helper_funcs);
 814
 815         /* Encoder */
 816
 817         encoder = &sdev->encoder;
 818         ret = drm_encoder_init(dev, encoder, &simpledrm_encoder_funcs,
 819                                DRM_MODE_ENCODER_NONE, NULL);
 820         if (ret)
 821                 return ERR_PTR(ret);
 822         encoder->possible_crtcs = drm_crtc_mask(crtc);
 823
 824         /* Connector */
 825
 826         connector = &sdev->connector;
 827         ret = drm_connector_init(dev, connector, &simpledrm_connector_funcs,
 828                                  DRM_MODE_CONNECTOR_Unknown);
 829         if (ret)
 830                 return ERR_PTR(ret);
 831         drm_connector_helper_add(connector, &simpledrm_connector_helper_funcs);
 832         drm_connector_set_panel_orientation_with_quirk(connector,
 833                                                        DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
 834                                                        width, height);
 835
 836         ret = drm_connector_attach_encoder(connector, encoder);
 837         if (ret)
 838                 return ERR_PTR(ret);
 839
 840         drm_mode_config_reset(dev);
 841
 842         return sdev;
 843 }
 844
 845 /*
 846  * DRM driver
 847  */
 848
 849 DEFINE_DRM_GEM_FOPS(simpledrm_fops);
 850
 851 static struct drm_driver simpledrm_driver = {
 852         DRM_GEM_SHMEM_DRIVER_OPS,
 853         .name                   = DRIVER_NAME,
 854         .desc                   = DRIVER_DESC,
 855         .date                   = DRIVER_DATE,
 856         .major                  = DRIVER_MAJOR,
 857         .minor                  = DRIVER_MINOR,
 858         .driver_features        = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
 859         .fops                   = &simpledrm_fops,
 860 };
 861
 862 /*
 863  * Platform driver
 864  */
 865
 866 static int simpledrm_probe(struct platform_device *pdev)
 867 {
 868         struct simpledrm_device *sdev;
 869         struct drm_device *dev;
 870         unsigned int color_mode;
 871         int ret;
 872
 873         sdev = simpledrm_device_create(&simpledrm_driver, pdev);
 874         if (IS_ERR(sdev))
 875                 return PTR_ERR(sdev);
 876         dev = &sdev->dev;
 877
 878         ret = drm_dev_register(dev, 0);
 879         if (ret)
 880                 return ret;
 881
 882         color_mode = drm_format_info_bpp(sdev->format, 0);
 883         if (color_mode == 16)
 884                 color_mode = sdev->format->depth; // can be 15 or 16
 885
 886         drm_fbdev_generic_setup(dev, color_mode);
 887
 888         return 0;
 889 }
 890
 891 static void simpledrm_remove(struct platform_device *pdev)
 892 {
 893         struct simpledrm_device *sdev = platform_get_drvdata(pdev);
 894         struct drm_device *dev = &sdev->dev;
 895
 896         drm_dev_unplug(dev);
 897 }
 898
 899 static const struct of_device_id simpledrm_of_match_table[] = {
 900         { .compatible = "simple-framebuffer", },
 901         { },
 902 };
 903 MODULE_DEVICE_TABLE(of, simpledrm_of_match_table);
 904
 905 static struct platform_driver simpledrm_platform_driver = {
 906         .driver = {
 907                 .name = "simple-framebuffer", /* connect to sysfb */
 908                 .of_match_table = simpledrm_of_match_table,
 909         },
 910         .probe = simpledrm_probe,
 911         .remove_new = simpledrm_remove,
 912 };
 913
 914 module_platform_driver(simpledrm_platform_driver);
 915
 916 MODULE_DESCRIPTION(DRIVER_DESC);
 917 MODULE_LICENSE("GPL v2");