drivers/video/fbdev/simplefb.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Simplest possible simple frame-buffer driver, as a platform device
   4  *
   5  * Copyright (c) 2013, Stephen Warren
   6  *
   7  * Based on q40fb.c, which was:
   8  * Copyright (C) 2001 Richard Zidlicky <rz@linux-m68k.org>
   9  *
  10  * Also based on offb.c, which was:
  11  * Copyright (C) 1997 Geert Uytterhoeven
  12  * Copyright (C) 1996 Paul Mackerras
  13  */
  14
  15 #include <linux/errno.h>
  16 #include <linux/fb.h>
  17 #include <linux/io.h>
  18 #include <linux/module.h>
  19 #include <linux/platform_data/simplefb.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/clk.h>
  22 #include <linux/of.h>
  23 #include <linux/of_clk.h>
  24 #include <linux/of_platform.h>
  25 #include <linux/parser.h>
  26 #include <linux/regulator/consumer.h>
  27
  28 static const struct fb_fix_screeninfo simplefb_fix = {
  29         .id             = "simple",
  30         .type           = FB_TYPE_PACKED_PIXELS,
  31         .visual         = FB_VISUAL_TRUECOLOR,
  32         .accel          = FB_ACCEL_NONE,
  33 };
  34
  35 static const struct fb_var_screeninfo simplefb_var = {
  36         .height         = -1,
  37         .width          = -1,
  38         .activate       = FB_ACTIVATE_NOW,
  39         .vmode          = FB_VMODE_NONINTERLACED,
  40 };
  41
  42 #define PSEUDO_PALETTE_SIZE 16
  43
  44 static int simplefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  45                               u_int transp, struct fb_info *info)
  46 {
  47         u32 *pal = info->pseudo_palette;
  48         u32 cr = red >> (16 - info->var.red.length);
  49         u32 cg = green >> (16 - info->var.green.length);
  50         u32 cb = blue >> (16 - info->var.blue.length);
  51         u32 value;
  52
  53         if (regno >= PSEUDO_PALETTE_SIZE)
  54                 return -EINVAL;
  55
  56         value = (cr << info->var.red.offset) |
  57                 (cg << info->var.green.offset) |
  58                 (cb << info->var.blue.offset);
  59         if (info->var.transp.length > 0) {
  60                 u32 mask = (1 << info->var.transp.length) - 1;
  61                 mask <<= info->var.transp.offset;
  62                 value |= mask;
  63         }
  64         pal[regno] = value;
  65
  66         return 0;
  67 }
  68
  69 struct simplefb_par {
  70         u32 palette[PSEUDO_PALETTE_SIZE];
  71         struct resource *mem;
  72 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
  73         bool clks_enabled;
  74         unsigned int clk_count;
  75         struct clk **clks;
  76 #endif
  77 #if defined CONFIG_OF && defined CONFIG_REGULATOR
  78         bool regulators_enabled;
  79         u32 regulator_count;
  80         struct regulator **regulators;
  81 #endif
  82 };
  83
  84 static void simplefb_clocks_destroy(struct simplefb_par *par);
  85 static void simplefb_regulators_destroy(struct simplefb_par *par);
  86
  87 /*
  88  * fb_ops.fb_destroy is called by the last put_fb_info() call at the end
  89  * of unregister_framebuffer() or fb_release(). Do any cleanup here.
  90  */
  91 static void simplefb_destroy(struct fb_info *info)
  92 {
  93         struct simplefb_par *par = info->par;
  94         struct resource *mem = par->mem;
  95
  96         simplefb_regulators_destroy(info->par);
  97         simplefb_clocks_destroy(info->par);
  98         if (info->screen_base)
  99                 iounmap(info->screen_base);
 100
 101         framebuffer_release(info);
 102
 103         if (mem)
 104                 release_mem_region(mem->start, resource_size(mem));
 105 }
 106
 107 static const struct fb_ops simplefb_ops = {
 108         .owner          = THIS_MODULE,
 109         .fb_destroy     = simplefb_destroy,
 110         .fb_setcolreg   = simplefb_setcolreg,
 111         .fb_fillrect    = cfb_fillrect,
 112         .fb_copyarea    = cfb_copyarea,
 113         .fb_imageblit   = cfb_imageblit,
 114 };
 115
 116 static struct simplefb_format simplefb_formats[] = SIMPLEFB_FORMATS;
 117
 118 struct simplefb_params {
 119         u32 width;
 120         u32 height;
 121         u32 stride;
 122         struct simplefb_format *format;
 123 };
 124
 125 static int simplefb_parse_dt(struct platform_device *pdev,
 126                            struct simplefb_params *params)
 127 {
 128         struct device_node *np = pdev->dev.of_node;
 129         int ret;
 130         const char *format;
 131         int i;
 132
 133         ret = of_property_read_u32(np, "width", &params->width);
 134         if (ret) {
 135                 dev_err(&pdev->dev, "Can't parse width property\n");
 136                 return ret;
 137         }
 138
 139         ret = of_property_read_u32(np, "height", &params->height);
 140         if (ret) {
 141                 dev_err(&pdev->dev, "Can't parse height property\n");
 142                 return ret;
 143         }
 144
 145         ret = of_property_read_u32(np, "stride", &params->stride);
 146         if (ret) {
 147                 dev_err(&pdev->dev, "Can't parse stride property\n");
 148                 return ret;
 149         }
 150
 151         ret = of_property_read_string(np, "format", &format);
 152         if (ret) {
 153                 dev_err(&pdev->dev, "Can't parse format property\n");
 154                 return ret;
 155         }
 156         params->format = NULL;
 157         for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
 158                 if (strcmp(format, simplefb_formats[i].name))
 159                         continue;
 160                 params->format = &simplefb_formats[i];
 161                 break;
 162         }
 163         if (!params->format) {
 164                 dev_err(&pdev->dev, "Invalid format value\n");
 165                 return -EINVAL;
 166         }
 167
 168         return 0;
 169 }
 170
 171 static int simplefb_parse_pd(struct platform_device *pdev,
 172                              struct simplefb_params *params)
 173 {
 174         struct simplefb_platform_data *pd = dev_get_platdata(&pdev->dev);
 175         int i;
 176
 177         params->width = pd->width;
 178         params->height = pd->height;
 179         params->stride = pd->stride;
 180
 181         params->format = NULL;
 182         for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
 183                 if (strcmp(pd->format, simplefb_formats[i].name))
 184                         continue;
 185
 186                 params->format = &simplefb_formats[i];
 187                 break;
 188         }
 189
 190         if (!params->format) {
 191                 dev_err(&pdev->dev, "Invalid format value\n");
 192                 return -EINVAL;
 193         }
 194
 195         return 0;
 196 }
 197
 198 #if defined CONFIG_OF && defined CONFIG_COMMON_CLK
 199 /*
 200  * Clock handling code.
 201  *
 202  * Here we handle the clocks property of our "simple-framebuffer" dt node.
 203  * This is necessary so that we can make sure that any clocks needed by
 204  * the display engine that the bootloader set up for us (and for which it
 205  * provided a simplefb dt node), stay up, for the life of the simplefb
 206  * driver.
 207  *
 208  * When the driver unloads, we cleanly disable, and then release the clocks.
 209  *
 210  * We only complain about errors here, no action is taken as the most likely
 211  * error can only happen due to a mismatch between the bootloader which set
 212  * up simplefb, and the clock definitions in the device tree. Chances are
 213  * that there are no adverse effects, and if there are, a clean teardown of
 214  * the fb probe will not help us much either. So just complain and carry on,
 215  * and hope that the user actually gets a working fb at the end of things.
 216  */
 217 static int simplefb_clocks_get(struct simplefb_par *par,
 218                                struct platform_device *pdev)
 219 {
 220         struct device_node *np = pdev->dev.of_node;
 221         struct clk *clock;
 222         int i;
 223
 224         if (dev_get_platdata(&pdev->dev) || !np)
 225                 return 0;
 226
 227         par->clk_count = of_clk_get_parent_count(np);
 228         if (!par->clk_count)
 229                 return 0;
 230
 231         par->clks = kcalloc(par->clk_count, sizeof(struct clk *), GFP_KERNEL);
 232         if (!par->clks)
 233                 return -ENOMEM;
 234
 235         for (i = 0; i < par->clk_count; i++) {
 236                 clock = of_clk_get(np, i);
 237                 if (IS_ERR(clock)) {
 238                         if (PTR_ERR(clock) == -EPROBE_DEFER) {
 239                                 while (--i >= 0) {
 240                                         clk_put(par->clks[i]);
 241                                 }
 242                                 kfree(par->clks);
 243                                 return -EPROBE_DEFER;
 244                         }
 245                         dev_err(&pdev->dev, "%s: clock %d not found: %ld\n",
 246                                 __func__, i, PTR_ERR(clock));
 247                         continue;
 248                 }
 249                 par->clks[i] = clock;
 250         }
 251
 252         return 0;
 253 }
 254
 255 static void simplefb_clocks_enable(struct simplefb_par *par,
 256                                    struct platform_device *pdev)
 257 {
 258         int i, ret;
 259
 260         for (i = 0; i < par->clk_count; i++) {
 261                 if (par->clks[i]) {
 262                         ret = clk_prepare_enable(par->clks[i]);
 263                         if (ret) {
 264                                 dev_err(&pdev->dev,
 265                                         "%s: failed to enable clock %d: %d\n",
 266                                         __func__, i, ret);
 267                                 clk_put(par->clks[i]);
 268                                 par->clks[i] = NULL;
 269                         }
 270                 }
 271         }
 272         par->clks_enabled = true;
 273 }
 274
 275 static void simplefb_clocks_destroy(struct simplefb_par *par)
 276 {
 277         int i;
 278
 279         if (!par->clks)
 280                 return;
 281
 282         for (i = 0; i < par->clk_count; i++) {
 283                 if (par->clks[i]) {
 284                         if (par->clks_enabled)
 285                                 clk_disable_unprepare(par->clks[i]);
 286                         clk_put(par->clks[i]);
 287                 }
 288         }
 289
 290         kfree(par->clks);
 291 }
 292 #else
 293 static int simplefb_clocks_get(struct simplefb_par *par,
 294         struct platform_device *pdev) { return 0; }
 295 static void simplefb_clocks_enable(struct simplefb_par *par,
 296         struct platform_device *pdev) { }
 297 static void simplefb_clocks_destroy(struct simplefb_par *par) { }
 298 #endif
 299
 300 #if defined CONFIG_OF && defined CONFIG_REGULATOR
 301
 302 #define SUPPLY_SUFFIX "-supply"
 303
 304 /*
 305  * Regulator handling code.
 306  *
 307  * Here we handle the num-supplies and vin*-supply properties of our
 308  * "simple-framebuffer" dt node. This is necessary so that we can make sure
 309  * that any regulators needed by the display hardware that the bootloader
 310  * set up for us (and for which it provided a simplefb dt node), stay up,
 311  * for the life of the simplefb driver.
 312  *
 313  * When the driver unloads, we cleanly disable, and then release the
 314  * regulators.
 315  *
 316  * We only complain about errors here, no action is taken as the most likely
 317  * error can only happen due to a mismatch between the bootloader which set
 318  * up simplefb, and the regulator definitions in the device tree. Chances are
 319  * that there are no adverse effects, and if there are, a clean teardown of
 320  * the fb probe will not help us much either. So just complain and carry on,
 321  * and hope that the user actually gets a working fb at the end of things.
 322  */
 323 static int simplefb_regulators_get(struct simplefb_par *par,
 324                                    struct platform_device *pdev)
 325 {
 326         struct device_node *np = pdev->dev.of_node;
 327         struct property *prop;
 328         struct regulator *regulator;
 329         const char *p;
 330         int count = 0, i = 0;
 331
 332         if (dev_get_platdata(&pdev->dev) || !np)
 333                 return 0;
 334
 335         /* Count the number of regulator supplies */
 336         for_each_property_of_node(np, prop) {
 337                 p = strstr(prop->name, SUPPLY_SUFFIX);
 338                 if (p && p != prop->name)
 339                         count++;
 340         }
 341
 342         if (!count)
 343                 return 0;
 344
 345         par->regulators = devm_kcalloc(&pdev->dev, count,
 346                                        sizeof(struct regulator *), GFP_KERNEL);
 347         if (!par->regulators)
 348                 return -ENOMEM;
 349
 350         /* Get all the regulators */
 351         for_each_property_of_node(np, prop) {
 352                 char name[32]; /* 32 is max size of property name */
 353
 354                 p = strstr(prop->name, SUPPLY_SUFFIX);
 355                 if (!p || p == prop->name)
 356                         continue;
 357
 358                 strlcpy(name, prop->name,
 359                         strlen(prop->name) - strlen(SUPPLY_SUFFIX) + 1);
 360                 regulator = devm_regulator_get_optional(&pdev->dev, name);
 361                 if (IS_ERR(regulator)) {
 362                         if (PTR_ERR(regulator) == -EPROBE_DEFER)
 363                                 return -EPROBE_DEFER;
 364                         dev_err(&pdev->dev, "regulator %s not found: %ld\n",
 365                                 name, PTR_ERR(regulator));
 366                         continue;
 367                 }
 368                 par->regulators[i++] = regulator;
 369         }
 370         par->regulator_count = i;
 371
 372         return 0;
 373 }
 374
 375 static void simplefb_regulators_enable(struct simplefb_par *par,
 376                                        struct platform_device *pdev)
 377 {
 378         int i, ret;
 379
 380         /* Enable all the regulators */
 381         for (i = 0; i < par->regulator_count; i++) {
 382                 ret = regulator_enable(par->regulators[i]);
 383                 if (ret) {
 384                         dev_err(&pdev->dev,
 385                                 "failed to enable regulator %d: %d\n",
 386                                 i, ret);
 387                         devm_regulator_put(par->regulators[i]);
 388                         par->regulators[i] = NULL;
 389                 }
 390         }
 391         par->regulators_enabled = true;
 392 }
 393
 394 static void simplefb_regulators_destroy(struct simplefb_par *par)
 395 {
 396         int i;
 397
 398         if (!par->regulators || !par->regulators_enabled)
 399                 return;
 400
 401         for (i = 0; i < par->regulator_count; i++)
 402                 if (par->regulators[i])
 403                         regulator_disable(par->regulators[i]);
 404 }
 405 #else
 406 static int simplefb_regulators_get(struct simplefb_par *par,
 407         struct platform_device *pdev) { return 0; }
 408 static void simplefb_regulators_enable(struct simplefb_par *par,
 409         struct platform_device *pdev) { }
 410 static void simplefb_regulators_destroy(struct simplefb_par *par) { }
 411 #endif
 412
 413 static int simplefb_probe(struct platform_device *pdev)
 414 {
 415         int ret;
 416         struct simplefb_params params;
 417         struct fb_info *info;
 418         struct simplefb_par *par;
 419         struct resource *res, *mem;
 420
 421         /*
 422          * Generic drivers must not be registered if a framebuffer exists.
 423          * If a native driver was probed, the display hardware was already
 424          * taken and attempting to use the system framebuffer is dangerous.
 425          */
 426         if (num_registered_fb > 0) {
 427                 dev_err(&pdev->dev,
 428                         "simplefb: a framebuffer is already registered\n");
 429                 return -EINVAL;
 430         }
 431
 432         if (fb_get_options("simplefb", NULL))
 433                 return -ENODEV;
 434
 435         ret = -ENODEV;
 436         if (dev_get_platdata(&pdev->dev))
 437                 ret = simplefb_parse_pd(pdev, &params);
 438         else if (pdev->dev.of_node)
 439                 ret = simplefb_parse_dt(pdev, &params);
 440
 441         if (ret)
 442                 return ret;
 443
 444         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 445         if (!res) {
 446                 dev_err(&pdev->dev, "No memory resource\n");
 447                 return -EINVAL;
 448         }
 449
 450         mem = request_mem_region(res->start, resource_size(res), "simplefb");
 451         if (!mem) {
 452                 /*
 453                  * We cannot make this fatal. Sometimes this comes from magic
 454                  * spaces our resource handlers simply don't know about. Use
 455                  * the I/O-memory resource as-is and try to map that instead.
 456                  */
 457                 dev_warn(&pdev->dev, "simplefb: cannot reserve video memory at %pR\n", res);
 458                 mem = res;
 459         }
 460
 461         info = framebuffer_alloc(sizeof(struct simplefb_par), &pdev->dev);
 462         if (!info) {
 463                 ret = -ENOMEM;
 464                 goto error_release_mem_region;
 465         }
 466         platform_set_drvdata(pdev, info);
 467
 468         par = info->par;
 469
 470         info->fix = simplefb_fix;
 471         info->fix.smem_start = mem->start;
 472         info->fix.smem_len = resource_size(mem);
 473         info->fix.line_length = params.stride;
 474
 475         info->var = simplefb_var;
 476         info->var.xres = params.width;
 477         info->var.yres = params.height;
 478         info->var.xres_virtual = params.width;
 479         info->var.yres_virtual = params.height;
 480         info->var.bits_per_pixel = params.format->bits_per_pixel;
 481         info->var.red = params.format->red;
 482         info->var.green = params.format->green;
 483         info->var.blue = params.format->blue;
 484         info->var.transp = params.format->transp;
 485
 486         info->apertures = alloc_apertures(1);
 487         if (!info->apertures) {
 488                 ret = -ENOMEM;
 489                 goto error_fb_release;
 490         }
 491         info->apertures->ranges[0].base = info->fix.smem_start;
 492         info->apertures->ranges[0].size = info->fix.smem_len;
 493
 494         info->fbops = &simplefb_ops;
 495         info->flags = FBINFO_DEFAULT | FBINFO_MISC_FIRMWARE;
 496         info->screen_base = ioremap_wc(info->fix.smem_start,
 497                                        info->fix.smem_len);
 498         if (!info->screen_base) {
 499                 ret = -ENOMEM;
 500                 goto error_fb_release;
 501         }
 502         info->pseudo_palette = par->palette;
 503
 504         ret = simplefb_clocks_get(par, pdev);
 505         if (ret < 0)
 506                 goto error_unmap;
 507
 508         ret = simplefb_regulators_get(par, pdev);
 509         if (ret < 0)
 510                 goto error_clocks;
 511
 512         simplefb_clocks_enable(par, pdev);
 513         simplefb_regulators_enable(par, pdev);
 514
 515         dev_info(&pdev->dev, "framebuffer at 0x%lx, 0x%x bytes\n",
 516                              info->fix.smem_start, info->fix.smem_len);
 517         dev_info(&pdev->dev, "format=%s, mode=%dx%dx%d, linelength=%d\n",
 518                              params.format->name,
 519                              info->var.xres, info->var.yres,
 520                              info->var.bits_per_pixel, info->fix.line_length);
 521
 522         if (mem != res)
 523                 par->mem = mem; /* release in clean-up handler */
 524
 525         ret = register_framebuffer(info);
 526         if (ret < 0) {
 527                 dev_err(&pdev->dev, "Unable to register simplefb: %d\n", ret);
 528                 goto error_regulators;
 529         }
 530
 531         dev_info(&pdev->dev, "fb%d: simplefb registered!\n", info->node);
 532
 533         return 0;
 534
 535 error_regulators:
 536         simplefb_regulators_destroy(par);
 537 error_clocks:
 538         simplefb_clocks_destroy(par);
 539 error_unmap:
 540         iounmap(info->screen_base);
 541 error_fb_release:
 542         framebuffer_release(info);
 543 error_release_mem_region:
 544         if (mem != res)
 545                 release_mem_region(mem->start, resource_size(mem));
 546         return ret;
 547 }
 548
 549 static int simplefb_remove(struct platform_device *pdev)
 550 {
 551         struct fb_info *info = platform_get_drvdata(pdev);
 552
 553         /* simplefb_destroy takes care of info cleanup */
 554         unregister_framebuffer(info);
 555
 556         return 0;
 557 }
 558
 559 static const struct of_device_id simplefb_of_match[] = {
 560         { .compatible = "simple-framebuffer", },
 561         { },
 562 };
 563 MODULE_DEVICE_TABLE(of, simplefb_of_match);
 564
 565 static struct platform_driver simplefb_driver = {
 566         .driver = {
 567                 .name = "simple-framebuffer",
 568                 .of_match_table = simplefb_of_match,
 569         },
 570         .probe = simplefb_probe,
 571         .remove = simplefb_remove,
 572 };
 573
 574 module_platform_driver(simplefb_driver);
 575
 576 MODULE_AUTHOR("Stephen Warren <swarren@wwwdotorg.org>");
 577 MODULE_DESCRIPTION("Simple framebuffer driver");
 578 MODULE_LICENSE("GPL v2");