drivers/gpu/drm/tiny/repaper.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * DRM driver for Pervasive Displays RePaper branded e-ink panels
   4  *
   5  * Copyright 2013-2017 Pervasive Displays, Inc.
   6  * Copyright 2017 Noralf Trønnes
   7  *
   8  * The driver supports:
   9  * Material Film: Aurora Mb (V231)
  10  * Driver IC: G2 (eTC)
  11  *
  12  * The controller code was taken from the userspace driver:
  13  * https://github.com/repaper/gratis
  14  */
  15
  16 #include <linux/delay.h>
  17 #include <linux/gpio/consumer.h>
  18 #include <linux/module.h>
  19 #include <linux/property.h>
  20 #include <linux/sched/clock.h>
  21 #include <linux/spi/spi.h>
  22 #include <linux/thermal.h>
  23
  24 #include <drm/drm_atomic_helper.h>
  25 #include <drm/drm_connector.h>
  26 #include <drm/drm_damage_helper.h>
  27 #include <drm/drm_drv.h>
  28 #include <drm/drm_fb_cma_helper.h>
  29 #include <drm/drm_fb_helper.h>
  30 #include <drm/drm_format_helper.h>
  31 #include <drm/drm_gem_atomic_helper.h>
  32 #include <drm/drm_gem_cma_helper.h>
  33 #include <drm/drm_gem_framebuffer_helper.h>
  34 #include <drm/drm_managed.h>
  35 #include <drm/drm_modes.h>
  36 #include <drm/drm_rect.h>
  37 #include <drm/drm_probe_helper.h>
  38 #include <drm/drm_simple_kms_helper.h>
  39
  40 #define REPAPER_RID_G2_COG_ID   0x12
  41
  42 enum repaper_model {
  43         /* 0 is reserved to avoid clashing with NULL */
  44         E1144CS021 = 1,
  45         E1190CS021,
  46         E2200CS021,
  47         E2271CS021,
  48 };
  49
  50 enum repaper_stage {         /* Image pixel -> Display pixel */
  51         REPAPER_COMPENSATE,  /* B -> W, W -> B (Current Image) */
  52         REPAPER_WHITE,       /* B -> N, W -> W (Current Image) */
  53         REPAPER_INVERSE,     /* B -> N, W -> B (New Image) */
  54         REPAPER_NORMAL       /* B -> B, W -> W (New Image) */
  55 };
  56
  57 enum repaper_epd_border_byte {
  58         REPAPER_BORDER_BYTE_NONE,
  59         REPAPER_BORDER_BYTE_ZERO,
  60         REPAPER_BORDER_BYTE_SET,
  61 };
  62
  63 struct repaper_epd {
  64         struct drm_device drm;
  65         struct drm_simple_display_pipe pipe;
  66         const struct drm_display_mode *mode;
  67         struct drm_connector connector;
  68         struct spi_device *spi;
  69
  70         struct gpio_desc *panel_on;
  71         struct gpio_desc *border;
  72         struct gpio_desc *discharge;
  73         struct gpio_desc *reset;
  74         struct gpio_desc *busy;
  75
  76         struct thermal_zone_device *thermal;
  77
  78         unsigned int height;
  79         unsigned int width;
  80         unsigned int bytes_per_scan;
  81         const u8 *channel_select;
  82         unsigned int stage_time;
  83         unsigned int factored_stage_time;
  84         bool middle_scan;
  85         bool pre_border_byte;
  86         enum repaper_epd_border_byte border_byte;
  87
  88         u8 *line_buffer;
  89         void *current_frame;
  90
  91         bool cleared;
  92         bool partial;
  93 };
  94
  95 static inline struct repaper_epd *drm_to_epd(struct drm_device *drm)
  96 {
  97         return container_of(drm, struct repaper_epd, drm);
  98 }
  99
 100 static int repaper_spi_transfer(struct spi_device *spi, u8 header,
 101                                 const void *tx, void *rx, size_t len)
 102 {
 103         void *txbuf = NULL, *rxbuf = NULL;
 104         struct spi_transfer tr[2] = {};
 105         u8 *headerbuf;
 106         int ret;
 107
 108         headerbuf = kmalloc(1, GFP_KERNEL);
 109         if (!headerbuf)
 110                 return -ENOMEM;
 111
 112         headerbuf[0] = header;
 113         tr[0].tx_buf = headerbuf;
 114         tr[0].len = 1;
 115
 116         /* Stack allocated tx? */
 117         if (tx && len <= 32) {
 118                 txbuf = kmemdup(tx, len, GFP_KERNEL);
 119                 if (!txbuf) {
 120                         ret = -ENOMEM;
 121                         goto out_free;
 122                 }
 123         }
 124
 125         if (rx) {
 126                 rxbuf = kmalloc(len, GFP_KERNEL);
 127                 if (!rxbuf) {
 128                         ret = -ENOMEM;
 129                         goto out_free;
 130                 }
 131         }
 132
 133         tr[1].tx_buf = txbuf ? txbuf : tx;
 134         tr[1].rx_buf = rxbuf;
 135         tr[1].len = len;
 136
 137         ndelay(80);
 138         ret = spi_sync_transfer(spi, tr, 2);
 139         if (rx && !ret)
 140                 memcpy(rx, rxbuf, len);
 141
 142 out_free:
 143         kfree(headerbuf);
 144         kfree(txbuf);
 145         kfree(rxbuf);
 146
 147         return ret;
 148 }
 149
 150 static int repaper_write_buf(struct spi_device *spi, u8 reg,
 151                              const u8 *buf, size_t len)
 152 {
 153         int ret;
 154
 155         ret = repaper_spi_transfer(spi, 0x70, &reg, NULL, 1);
 156         if (ret)
 157                 return ret;
 158
 159         return repaper_spi_transfer(spi, 0x72, buf, NULL, len);
 160 }
 161
 162 static int repaper_write_val(struct spi_device *spi, u8 reg, u8 val)
 163 {
 164         return repaper_write_buf(spi, reg, &val, 1);
 165 }
 166
 167 static int repaper_read_val(struct spi_device *spi, u8 reg)
 168 {
 169         int ret;
 170         u8 val;
 171
 172         ret = repaper_spi_transfer(spi, 0x70, &reg, NULL, 1);
 173         if (ret)
 174                 return ret;
 175
 176         ret = repaper_spi_transfer(spi, 0x73, NULL, &val, 1);
 177
 178         return ret ? ret : val;
 179 }
 180
 181 static int repaper_read_id(struct spi_device *spi)
 182 {
 183         int ret;
 184         u8 id;
 185
 186         ret = repaper_spi_transfer(spi, 0x71, NULL, &id, 1);
 187
 188         return ret ? ret : id;
 189 }
 190
 191 static void repaper_spi_mosi_low(struct spi_device *spi)
 192 {
 193         const u8 buf[1] = { 0 };
 194
 195         spi_write(spi, buf, 1);
 196 }
 197
 198 /* pixels on display are numbered from 1 so even is actually bits 1,3,5,... */
 199 static void repaper_even_pixels(struct repaper_epd *epd, u8 **pp,
 200                                 const u8 *data, u8 fixed_value, const u8 *mask,
 201                                 enum repaper_stage stage)
 202 {
 203         unsigned int b;
 204
 205         for (b = 0; b < (epd->width / 8); b++) {
 206                 if (data) {
 207                         u8 pixels = data[b] & 0xaa;
 208                         u8 pixel_mask = 0xff;
 209                         u8 p1, p2, p3, p4;
 210
 211                         if (mask) {
 212                                 pixel_mask = (mask[b] ^ pixels) & 0xaa;
 213                                 pixel_mask |= pixel_mask >> 1;
 214                         }
 215
 216                         switch (stage) {
 217                         case REPAPER_COMPENSATE: /* B -> W, W -> B (Current) */
 218                                 pixels = 0xaa | ((pixels ^ 0xaa) >> 1);
 219                                 break;
 220                         case REPAPER_WHITE:      /* B -> N, W -> W (Current) */
 221                                 pixels = 0x55 + ((pixels ^ 0xaa) >> 1);
 222                                 break;
 223                         case REPAPER_INVERSE:    /* B -> N, W -> B (New) */
 224                                 pixels = 0x55 | (pixels ^ 0xaa);
 225                                 break;
 226                         case REPAPER_NORMAL:     /* B -> B, W -> W (New) */
 227                                 pixels = 0xaa | (pixels >> 1);
 228                                 break;
 229                         }
 230
 231                         pixels = (pixels & pixel_mask) | (~pixel_mask & 0x55);
 232                         p1 = (pixels >> 6) & 0x03;
 233                         p2 = (pixels >> 4) & 0x03;
 234                         p3 = (pixels >> 2) & 0x03;
 235                         p4 = (pixels >> 0) & 0x03;
 236                         pixels = (p1 << 0) | (p2 << 2) | (p3 << 4) | (p4 << 6);
 237                         *(*pp)++ = pixels;
 238                 } else {
 239                         *(*pp)++ = fixed_value;
 240                 }
 241         }
 242 }
 243
 244 /* pixels on display are numbered from 1 so odd is actually bits 0,2,4,... */
 245 static void repaper_odd_pixels(struct repaper_epd *epd, u8 **pp,
 246                                const u8 *data, u8 fixed_value, const u8 *mask,
 247                                enum repaper_stage stage)
 248 {
 249         unsigned int b;
 250
 251         for (b = epd->width / 8; b > 0; b--) {
 252                 if (data) {
 253                         u8 pixels = data[b - 1] & 0x55;
 254                         u8 pixel_mask = 0xff;
 255
 256                         if (mask) {
 257                                 pixel_mask = (mask[b - 1] ^ pixels) & 0x55;
 258                                 pixel_mask |= pixel_mask << 1;
 259                         }
 260
 261                         switch (stage) {
 262                         case REPAPER_COMPENSATE: /* B -> W, W -> B (Current) */
 263                                 pixels = 0xaa | (pixels ^ 0x55);
 264                                 break;
 265                         case REPAPER_WHITE:      /* B -> N, W -> W (Current) */
 266                                 pixels = 0x55 + (pixels ^ 0x55);
 267                                 break;
 268                         case REPAPER_INVERSE:    /* B -> N, W -> B (New) */
 269                                 pixels = 0x55 | ((pixels ^ 0x55) << 1);
 270                                 break;
 271                         case REPAPER_NORMAL:     /* B -> B, W -> W (New) */
 272                                 pixels = 0xaa | pixels;
 273                                 break;
 274                         }
 275
 276                         pixels = (pixels & pixel_mask) | (~pixel_mask & 0x55);
 277                         *(*pp)++ = pixels;
 278                 } else {
 279                         *(*pp)++ = fixed_value;
 280                 }
 281         }
 282 }
 283
 284 /* interleave bits: (byte)76543210 -> (16 bit).7.6.5.4.3.2.1 */
 285 static inline u16 repaper_interleave_bits(u16 value)
 286 {
 287         value = (value | (value << 4)) & 0x0f0f;
 288         value = (value | (value << 2)) & 0x3333;
 289         value = (value | (value << 1)) & 0x5555;
 290
 291         return value;
 292 }
 293
 294 /* pixels on display are numbered from 1 */
 295 static void repaper_all_pixels(struct repaper_epd *epd, u8 **pp,
 296                                const u8 *data, u8 fixed_value, const u8 *mask,
 297                                enum repaper_stage stage)
 298 {
 299         unsigned int b;
 300
 301         for (b = epd->width / 8; b > 0; b--) {
 302                 if (data) {
 303                         u16 pixels = repaper_interleave_bits(data[b - 1]);
 304                         u16 pixel_mask = 0xffff;
 305
 306                         if (mask) {
 307                                 pixel_mask = repaper_interleave_bits(mask[b - 1]);
 308
 309                                 pixel_mask = (pixel_mask ^ pixels) & 0x5555;
 310                                 pixel_mask |= pixel_mask << 1;
 311                         }
 312
 313                         switch (stage) {
 314                         case REPAPER_COMPENSATE: /* B -> W, W -> B (Current) */
 315                                 pixels = 0xaaaa | (pixels ^ 0x5555);
 316                                 break;
 317                         case REPAPER_WHITE:      /* B -> N, W -> W (Current) */
 318                                 pixels = 0x5555 + (pixels ^ 0x5555);
 319                                 break;
 320                         case REPAPER_INVERSE:    /* B -> N, W -> B (New) */
 321                                 pixels = 0x5555 | ((pixels ^ 0x5555) << 1);
 322                                 break;
 323                         case REPAPER_NORMAL:     /* B -> B, W -> W (New) */
 324                                 pixels = 0xaaaa | pixels;
 325                                 break;
 326                         }
 327
 328                         pixels = (pixels & pixel_mask) | (~pixel_mask & 0x5555);
 329                         *(*pp)++ = pixels >> 8;
 330                         *(*pp)++ = pixels;
 331                 } else {
 332                         *(*pp)++ = fixed_value;
 333                         *(*pp)++ = fixed_value;
 334                 }
 335         }
 336 }
 337
 338 /* output one line of scan and data bytes to the display */
 339 static void repaper_one_line(struct repaper_epd *epd, unsigned int line,
 340                              const u8 *data, u8 fixed_value, const u8 *mask,
 341                              enum repaper_stage stage)
 342 {
 343         u8 *p = epd->line_buffer;
 344         unsigned int b;
 345
 346         repaper_spi_mosi_low(epd->spi);
 347
 348         if (epd->pre_border_byte)
 349                 *p++ = 0x00;
 350
 351         if (epd->middle_scan) {
 352                 /* data bytes */
 353                 repaper_odd_pixels(epd, &p, data, fixed_value, mask, stage);
 354
 355                 /* scan line */
 356                 for (b = epd->bytes_per_scan; b > 0; b--) {
 357                         if (line / 4 == b - 1)
 358                                 *p++ = 0x03 << (2 * (line & 0x03));
 359                         else
 360                                 *p++ = 0x00;
 361                 }
 362
 363                 /* data bytes */
 364                 repaper_even_pixels(epd, &p, data, fixed_value, mask, stage);
 365         } else {
 366                 /*
 367                  * even scan line, but as lines on display are numbered from 1,
 368                  * line: 1,3,5,...
 369                  */
 370                 for (b = 0; b < epd->bytes_per_scan; b++) {
 371                         if (0 != (line & 0x01) && line / 8 == b)
 372                                 *p++ = 0xc0 >> (line & 0x06);
 373                         else
 374                                 *p++ = 0x00;
 375                 }
 376
 377                 /* data bytes */
 378                 repaper_all_pixels(epd, &p, data, fixed_value, mask, stage);
 379
 380                 /*
 381                  * odd scan line, but as lines on display are numbered from 1,
 382                  * line: 0,2,4,6,...
 383                  */
 384                 for (b = epd->bytes_per_scan; b > 0; b--) {
 385                         if (0 == (line & 0x01) && line / 8 == b - 1)
 386                                 *p++ = 0x03 << (line & 0x06);
 387                         else
 388                                 *p++ = 0x00;
 389                 }
 390         }
 391
 392         switch (epd->border_byte) {
 393         case REPAPER_BORDER_BYTE_NONE:
 394                 break;
 395
 396         case REPAPER_BORDER_BYTE_ZERO:
 397                 *p++ = 0x00;
 398                 break;
 399
 400         case REPAPER_BORDER_BYTE_SET:
 401                 switch (stage) {
 402                 case REPAPER_COMPENSATE:
 403                 case REPAPER_WHITE:
 404                 case REPAPER_INVERSE:
 405                         *p++ = 0x00;
 406                         break;
 407                 case REPAPER_NORMAL:
 408                         *p++ = 0xaa;
 409                         break;
 410                 }
 411                 break;
 412         }
 413
 414         repaper_write_buf(epd->spi, 0x0a, epd->line_buffer,
 415                           p - epd->line_buffer);
 416
 417         /* Output data to panel */
 418         repaper_write_val(epd->spi, 0x02, 0x07);
 419
 420         repaper_spi_mosi_low(epd->spi);
 421 }
 422
 423 static void repaper_frame_fixed(struct repaper_epd *epd, u8 fixed_value,
 424                                 enum repaper_stage stage)
 425 {
 426         unsigned int line;
 427
 428         for (line = 0; line < epd->height; line++)
 429                 repaper_one_line(epd, line, NULL, fixed_value, NULL, stage);
 430 }
 431
 432 static void repaper_frame_data(struct repaper_epd *epd, const u8 *image,
 433                                const u8 *mask, enum repaper_stage stage)
 434 {
 435         unsigned int line;
 436
 437         if (!mask) {
 438                 for (line = 0; line < epd->height; line++) {
 439                         repaper_one_line(epd, line,
 440                                          &image[line * (epd->width / 8)],
 441                                          0, NULL, stage);
 442                 }
 443         } else {
 444                 for (line = 0; line < epd->height; line++) {
 445                         size_t n = line * epd->width / 8;
 446
 447                         repaper_one_line(epd, line, &image[n], 0, &mask[n],
 448                                          stage);
 449                 }
 450         }
 451 }
 452
 453 static void repaper_frame_fixed_repeat(struct repaper_epd *epd, u8 fixed_value,
 454                                        enum repaper_stage stage)
 455 {
 456         u64 start = local_clock();
 457         u64 end = start + (epd->factored_stage_time * 1000 * 1000);
 458
 459         do {
 460                 repaper_frame_fixed(epd, fixed_value, stage);
 461         } while (local_clock() < end);
 462 }
 463
 464 static void repaper_frame_data_repeat(struct repaper_epd *epd, const u8 *image,
 465                                       const u8 *mask, enum repaper_stage stage)
 466 {
 467         u64 start = local_clock();
 468         u64 end = start + (epd->factored_stage_time * 1000 * 1000);
 469
 470         do {
 471                 repaper_frame_data(epd, image, mask, stage);
 472         } while (local_clock() < end);
 473 }
 474
 475 static void repaper_get_temperature(struct repaper_epd *epd)
 476 {
 477         int ret, temperature = 0;
 478         unsigned int factor10x;
 479
 480         if (!epd->thermal)
 481                 return;
 482
 483         ret = thermal_zone_get_temp(epd->thermal, &temperature);
 484         if (ret) {
 485                 DRM_DEV_ERROR(&epd->spi->dev, "Failed to get temperature (%d)\n", ret);
 486                 return;
 487         }
 488
 489         temperature /= 1000;
 490
 491         if (temperature <= -10)
 492                 factor10x = 170;
 493         else if (temperature <= -5)
 494                 factor10x = 120;
 495         else if (temperature <= 5)
 496                 factor10x = 80;
 497         else if (temperature <= 10)
 498                 factor10x = 40;
 499         else if (temperature <= 15)
 500                 factor10x = 30;
 501         else if (temperature <= 20)
 502                 factor10x = 20;
 503         else if (temperature <= 40)
 504                 factor10x = 10;
 505         else
 506                 factor10x = 7;
 507
 508         epd->factored_stage_time = epd->stage_time * factor10x / 10;
 509 }
 510
 511 static void repaper_gray8_to_mono_reversed(u8 *buf, u32 width, u32 height)
 512 {
 513         u8 *gray8 = buf, *mono = buf;
 514         int y, xb, i;
 515
 516         for (y = 0; y < height; y++)
 517                 for (xb = 0; xb < width / 8; xb++) {
 518                         u8 byte = 0x00;
 519
 520                         for (i = 0; i < 8; i++) {
 521                                 int x = xb * 8 + i;
 522
 523                                 byte >>= 1;
 524                                 if (gray8[y * width + x] >> 7)
 525                                         byte |= BIT(7);
 526                         }
 527                         *mono++ = byte;
 528                 }
 529 }
 530
 531 static int repaper_fb_dirty(struct drm_framebuffer *fb)
 532 {
 533         struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
 534         struct repaper_epd *epd = drm_to_epd(fb->dev);
 535         struct drm_rect clip;
 536         int idx, ret = 0;
 537         u8 *buf = NULL;
 538
 539         if (!drm_dev_enter(fb->dev, &idx))
 540                 return -ENODEV;
 541
 542         /* repaper can't do partial updates */
 543         clip.x1 = 0;
 544         clip.x2 = fb->width;
 545         clip.y1 = 0;
 546         clip.y2 = fb->height;
 547
 548         repaper_get_temperature(epd);
 549
 550         DRM_DEBUG("Flushing [FB:%d] st=%ums\n", fb->base.id,
 551                   epd->factored_stage_time);
 552
 553         buf = kmalloc_array(fb->width, fb->height, GFP_KERNEL);
 554         if (!buf) {
 555                 ret = -ENOMEM;
 556                 goto out_exit;
 557         }
 558
 559         ret = drm_gem_fb_begin_cpu_access(fb, DMA_FROM_DEVICE);
 560         if (ret)
 561                 goto out_free;
 562
 563         drm_fb_xrgb8888_to_gray8(buf, cma_obj->vaddr, fb, &clip);
 564
 565         drm_gem_fb_end_cpu_access(fb, DMA_FROM_DEVICE);
 566
 567         repaper_gray8_to_mono_reversed(buf, fb->width, fb->height);
 568
 569         if (epd->partial) {
 570                 repaper_frame_data_repeat(epd, buf, epd->current_frame,
 571                                           REPAPER_NORMAL);
 572         } else if (epd->cleared) {
 573                 repaper_frame_data_repeat(epd, epd->current_frame, NULL,
 574                                           REPAPER_COMPENSATE);
 575                 repaper_frame_data_repeat(epd, epd->current_frame, NULL,
 576                                           REPAPER_WHITE);
 577                 repaper_frame_data_repeat(epd, buf, NULL, REPAPER_INVERSE);
 578                 repaper_frame_data_repeat(epd, buf, NULL, REPAPER_NORMAL);
 579
 580                 epd->partial = true;
 581         } else {
 582                 /* Clear display (anything -> white) */
 583                 repaper_frame_fixed_repeat(epd, 0xff, REPAPER_COMPENSATE);
 584                 repaper_frame_fixed_repeat(epd, 0xff, REPAPER_WHITE);
 585                 repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_INVERSE);
 586                 repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_NORMAL);
 587
 588                 /* Assuming a clear (white) screen output an image */
 589                 repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_COMPENSATE);
 590                 repaper_frame_fixed_repeat(epd, 0xaa, REPAPER_WHITE);
 591                 repaper_frame_data_repeat(epd, buf, NULL, REPAPER_INVERSE);
 592                 repaper_frame_data_repeat(epd, buf, NULL, REPAPER_NORMAL);
 593
 594                 epd->cleared = true;
 595                 epd->partial = true;
 596         }
 597
 598         memcpy(epd->current_frame, buf, fb->width * fb->height / 8);
 599
 600         /*
 601          * An extra frame write is needed if pixels are set in the bottom line,
 602          * or else grey lines rises up from the pixels
 603          */
 604         if (epd->pre_border_byte) {
 605                 unsigned int x;
 606
 607                 for (x = 0; x < (fb->width / 8); x++)
 608                         if (buf[x + (fb->width * (fb->height - 1) / 8)]) {
 609                                 repaper_frame_data_repeat(epd, buf,
 610                                                           epd->current_frame,
 611                                                           REPAPER_NORMAL);
 612                                 break;
 613                         }
 614         }
 615
 616 out_free:
 617         kfree(buf);
 618 out_exit:
 619         drm_dev_exit(idx);
 620
 621         return ret;
 622 }
 623
 624 static void power_off(struct repaper_epd *epd)
 625 {
 626         /* Turn off power and all signals */
 627         gpiod_set_value_cansleep(epd->reset, 0);
 628         gpiod_set_value_cansleep(epd->panel_on, 0);
 629         if (epd->border)
 630                 gpiod_set_value_cansleep(epd->border, 0);
 631
 632         /* Ensure SPI MOSI and CLOCK are Low before CS Low */
 633         repaper_spi_mosi_low(epd->spi);
 634
 635         /* Discharge pulse */
 636         gpiod_set_value_cansleep(epd->discharge, 1);
 637         msleep(150);
 638         gpiod_set_value_cansleep(epd->discharge, 0);
 639 }
 640
 641 static void repaper_pipe_enable(struct drm_simple_display_pipe *pipe,
 642                                 struct drm_crtc_state *crtc_state,
 643                                 struct drm_plane_state *plane_state)
 644 {
 645         struct repaper_epd *epd = drm_to_epd(pipe->crtc.dev);
 646         struct spi_device *spi = epd->spi;
 647         struct device *dev = &spi->dev;
 648         bool dc_ok = false;
 649         int i, ret, idx;
 650
 651         if (!drm_dev_enter(pipe->crtc.dev, &idx))
 652                 return;
 653
 654         DRM_DEBUG_DRIVER("\n");
 655
 656         /* Power up sequence */
 657         gpiod_set_value_cansleep(epd->reset, 0);
 658         gpiod_set_value_cansleep(epd->panel_on, 0);
 659         gpiod_set_value_cansleep(epd->discharge, 0);
 660         if (epd->border)
 661                 gpiod_set_value_cansleep(epd->border, 0);
 662         repaper_spi_mosi_low(spi);
 663         usleep_range(5000, 10000);
 664
 665         gpiod_set_value_cansleep(epd->panel_on, 1);
 666         /*
 667          * This delay comes from the repaper.org userspace driver, it's not
 668          * mentioned in the datasheet.
 669          */
 670         usleep_range(10000, 15000);
 671         gpiod_set_value_cansleep(epd->reset, 1);
 672         if (epd->border)
 673                 gpiod_set_value_cansleep(epd->border, 1);
 674         usleep_range(5000, 10000);
 675         gpiod_set_value_cansleep(epd->reset, 0);
 676         usleep_range(5000, 10000);
 677         gpiod_set_value_cansleep(epd->reset, 1);
 678         usleep_range(5000, 10000);
 679
 680         /* Wait for COG to become ready */
 681         for (i = 100; i > 0; i--) {
 682                 if (!gpiod_get_value_cansleep(epd->busy))
 683                         break;
 684
 685                 usleep_range(10, 100);
 686         }
 687
 688         if (!i) {
 689                 DRM_DEV_ERROR(dev, "timeout waiting for panel to become ready.\n");
 690                 power_off(epd);
 691                 goto out_exit;
 692         }
 693
 694         repaper_read_id(spi);
 695         ret = repaper_read_id(spi);
 696         if (ret != REPAPER_RID_G2_COG_ID) {
 697                 if (ret < 0)
 698                         dev_err(dev, "failed to read chip (%d)\n", ret);
 699                 else
 700                         dev_err(dev, "wrong COG ID 0x%02x\n", ret);
 701                 power_off(epd);
 702                 goto out_exit;
 703         }
 704
 705         /* Disable OE */
 706         repaper_write_val(spi, 0x02, 0x40);
 707
 708         ret = repaper_read_val(spi, 0x0f);
 709         if (ret < 0 || !(ret & 0x80)) {
 710                 if (ret < 0)
 711                         DRM_DEV_ERROR(dev, "failed to read chip (%d)\n", ret);
 712                 else
 713                         DRM_DEV_ERROR(dev, "panel is reported broken\n");
 714                 power_off(epd);
 715                 goto out_exit;
 716         }
 717
 718         /* Power saving mode */
 719         repaper_write_val(spi, 0x0b, 0x02);
 720         /* Channel select */
 721         repaper_write_buf(spi, 0x01, epd->channel_select, 8);
 722         /* High power mode osc */
 723         repaper_write_val(spi, 0x07, 0xd1);
 724         /* Power setting */
 725         repaper_write_val(spi, 0x08, 0x02);
 726         /* Vcom level */
 727         repaper_write_val(spi, 0x09, 0xc2);
 728         /* Power setting */
 729         repaper_write_val(spi, 0x04, 0x03);
 730         /* Driver latch on */
 731         repaper_write_val(spi, 0x03, 0x01);
 732         /* Driver latch off */
 733         repaper_write_val(spi, 0x03, 0x00);
 734         usleep_range(5000, 10000);
 735
 736         /* Start chargepump */
 737         for (i = 0; i < 4; ++i) {
 738                 /* Charge pump positive voltage on - VGH/VDL on */
 739                 repaper_write_val(spi, 0x05, 0x01);
 740                 msleep(240);
 741
 742                 /* Charge pump negative voltage on - VGL/VDL on */
 743                 repaper_write_val(spi, 0x05, 0x03);
 744                 msleep(40);
 745
 746                 /* Charge pump Vcom on - Vcom driver on */
 747                 repaper_write_val(spi, 0x05, 0x0f);
 748                 msleep(40);
 749
 750                 /* check DC/DC */
 751                 ret = repaper_read_val(spi, 0x0f);
 752                 if (ret < 0) {
 753                         DRM_DEV_ERROR(dev, "failed to read chip (%d)\n", ret);
 754                         power_off(epd);
 755                         goto out_exit;
 756                 }
 757
 758                 if (ret & 0x40) {
 759                         dc_ok = true;
 760                         break;
 761                 }
 762         }
 763
 764         if (!dc_ok) {
 765                 DRM_DEV_ERROR(dev, "dc/dc failed\n");
 766                 power_off(epd);
 767                 goto out_exit;
 768         }
 769
 770         /*
 771          * Output enable to disable
 772          * The userspace driver sets this to 0x04, but the datasheet says 0x06
 773          */
 774         repaper_write_val(spi, 0x02, 0x04);
 775
 776         epd->partial = false;
 777 out_exit:
 778         drm_dev_exit(idx);
 779 }
 780
 781 static void repaper_pipe_disable(struct drm_simple_display_pipe *pipe)
 782 {
 783         struct repaper_epd *epd = drm_to_epd(pipe->crtc.dev);
 784         struct spi_device *spi = epd->spi;
 785         unsigned int line;
 786
 787         /*
 788          * This callback is not protected by drm_dev_enter/exit since we want to
 789          * turn off the display on regular driver unload. It's highly unlikely
 790          * that the underlying SPI controller is gone should this be called after
 791          * unplug.
 792          */
 793
 794         DRM_DEBUG_DRIVER("\n");
 795
 796         /* Nothing frame */
 797         for (line = 0; line < epd->height; line++)
 798                 repaper_one_line(epd, 0x7fffu, NULL, 0x00, NULL,
 799                                  REPAPER_COMPENSATE);
 800
 801         /* 2.7" */
 802         if (epd->border) {
 803                 /* Dummy line */
 804                 repaper_one_line(epd, 0x7fffu, NULL, 0x00, NULL,
 805                                  REPAPER_COMPENSATE);
 806                 msleep(25);
 807                 gpiod_set_value_cansleep(epd->border, 0);
 808                 msleep(200);
 809                 gpiod_set_value_cansleep(epd->border, 1);
 810         } else {
 811                 /* Border dummy line */
 812                 repaper_one_line(epd, 0x7fffu, NULL, 0x00, NULL,
 813                                  REPAPER_NORMAL);
 814                 msleep(200);
 815         }
 816
 817         /* not described in datasheet */
 818         repaper_write_val(spi, 0x0b, 0x00);
 819         /* Latch reset turn on */
 820         repaper_write_val(spi, 0x03, 0x01);
 821         /* Power off charge pump Vcom */
 822         repaper_write_val(spi, 0x05, 0x03);
 823         /* Power off charge pump neg voltage */
 824         repaper_write_val(spi, 0x05, 0x01);
 825         msleep(120);
 826         /* Discharge internal */
 827         repaper_write_val(spi, 0x04, 0x80);
 828         /* turn off all charge pumps */
 829         repaper_write_val(spi, 0x05, 0x00);
 830         /* Turn off osc */
 831         repaper_write_val(spi, 0x07, 0x01);
 832         msleep(50);
 833
 834         power_off(epd);
 835 }
 836
 837 static void repaper_pipe_update(struct drm_simple_display_pipe *pipe,
 838                                 struct drm_plane_state *old_state)
 839 {
 840         struct drm_plane_state *state = pipe->plane.state;
 841         struct drm_rect rect;
 842
 843         if (!pipe->crtc.state->active)
 844                 return;
 845
 846         if (drm_atomic_helper_damage_merged(old_state, state, &rect))
 847                 repaper_fb_dirty(state->fb);
 848 }
 849
 850 static const struct drm_simple_display_pipe_funcs repaper_pipe_funcs = {
 851         .enable = repaper_pipe_enable,
 852         .disable = repaper_pipe_disable,
 853         .update = repaper_pipe_update,
 854 };
 855
 856 static int repaper_connector_get_modes(struct drm_connector *connector)
 857 {
 858         struct repaper_epd *epd = drm_to_epd(connector->dev);
 859         struct drm_display_mode *mode;
 860
 861         mode = drm_mode_duplicate(connector->dev, epd->mode);
 862         if (!mode) {
 863                 DRM_ERROR("Failed to duplicate mode\n");
 864                 return 0;
 865         }
 866
 867         drm_mode_set_name(mode);
 868         mode->type |= DRM_MODE_TYPE_PREFERRED;
 869         drm_mode_probed_add(connector, mode);
 870
 871         connector->display_info.width_mm = mode->width_mm;
 872         connector->display_info.height_mm = mode->height_mm;
 873
 874         return 1;
 875 }
 876
 877 static const struct drm_connector_helper_funcs repaper_connector_hfuncs = {
 878         .get_modes = repaper_connector_get_modes,
 879 };
 880
 881 static const struct drm_connector_funcs repaper_connector_funcs = {
 882         .reset = drm_atomic_helper_connector_reset,
 883         .fill_modes = drm_helper_probe_single_connector_modes,
 884         .destroy = drm_connector_cleanup,
 885         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 886         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 887 };
 888
 889 static const struct drm_mode_config_funcs repaper_mode_config_funcs = {
 890         .fb_create = drm_gem_fb_create_with_dirty,
 891         .atomic_check = drm_atomic_helper_check,
 892         .atomic_commit = drm_atomic_helper_commit,
 893 };
 894
 895 static const uint32_t repaper_formats[] = {
 896         DRM_FORMAT_XRGB8888,
 897 };
 898
 899 static const struct drm_display_mode repaper_e1144cs021_mode = {
 900         DRM_SIMPLE_MODE(128, 96, 29, 22),
 901 };
 902
 903 static const u8 repaper_e1144cs021_cs[] = { 0x00, 0x00, 0x00, 0x00,
 904                                             0x00, 0x0f, 0xff, 0x00 };
 905
 906 static const struct drm_display_mode repaper_e1190cs021_mode = {
 907         DRM_SIMPLE_MODE(144, 128, 36, 32),
 908 };
 909
 910 static const u8 repaper_e1190cs021_cs[] = { 0x00, 0x00, 0x00, 0x03,
 911                                             0xfc, 0x00, 0x00, 0xff };
 912
 913 static const struct drm_display_mode repaper_e2200cs021_mode = {
 914         DRM_SIMPLE_MODE(200, 96, 46, 22),
 915 };
 916
 917 static const u8 repaper_e2200cs021_cs[] = { 0x00, 0x00, 0x00, 0x00,
 918                                             0x01, 0xff, 0xe0, 0x00 };
 919
 920 static const struct drm_display_mode repaper_e2271cs021_mode = {
 921         DRM_SIMPLE_MODE(264, 176, 57, 38),
 922 };
 923
 924 static const u8 repaper_e2271cs021_cs[] = { 0x00, 0x00, 0x00, 0x7f,
 925                                             0xff, 0xfe, 0x00, 0x00 };
 926
 927 DEFINE_DRM_GEM_CMA_FOPS(repaper_fops);
 928
 929 static const struct drm_driver repaper_driver = {
 930         .driver_features        = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
 931         .fops                   = &repaper_fops,
 932         DRM_GEM_CMA_DRIVER_OPS_VMAP,
 933         .name                   = "repaper",
 934         .desc                   = "Pervasive Displays RePaper e-ink panels",
 935         .date                   = "20170405",
 936         .major                  = 1,
 937         .minor                  = 0,
 938 };
 939
 940 static const struct of_device_id repaper_of_match[] = {
 941         { .compatible = "pervasive,e1144cs021", .data = (void *)E1144CS021 },
 942         { .compatible = "pervasive,e1190cs021", .data = (void *)E1190CS021 },
 943         { .compatible = "pervasive,e2200cs021", .data = (void *)E2200CS021 },
 944         { .compatible = "pervasive,e2271cs021", .data = (void *)E2271CS021 },
 945         {},
 946 };
 947 MODULE_DEVICE_TABLE(of, repaper_of_match);
 948
 949 static const struct spi_device_id repaper_id[] = {
 950         { "e1144cs021", E1144CS021 },
 951         { "e1190cs021", E1190CS021 },
 952         { "e2200cs021", E2200CS021 },
 953         { "e2271cs021", E2271CS021 },
 954         { },
 955 };
 956 MODULE_DEVICE_TABLE(spi, repaper_id);
 957
 958 static int repaper_probe(struct spi_device *spi)
 959 {
 960         const struct drm_display_mode *mode;
 961         const struct spi_device_id *spi_id;
 962         struct device *dev = &spi->dev;
 963         enum repaper_model model;
 964         const char *thermal_zone;
 965         struct repaper_epd *epd;
 966         size_t line_buffer_size;
 967         struct drm_device *drm;
 968         const void *match;
 969         int ret;
 970
 971         match = device_get_match_data(dev);
 972         if (match) {
 973                 model = (enum repaper_model)match;
 974         } else {
 975                 spi_id = spi_get_device_id(spi);
 976                 model = (enum repaper_model)spi_id->driver_data;
 977         }
 978
 979         /* The SPI device is used to allocate dma memory */
 980         if (!dev->coherent_dma_mask) {
 981                 ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
 982                 if (ret) {
 983                         dev_warn(dev, "Failed to set dma mask %d\n", ret);
 984                         return ret;
 985                 }
 986         }
 987
 988         epd = devm_drm_dev_alloc(dev, &repaper_driver,
 989                                  struct repaper_epd, drm);
 990         if (IS_ERR(epd))
 991                 return PTR_ERR(epd);
 992
 993         drm = &epd->drm;
 994
 995         ret = drmm_mode_config_init(drm);
 996         if (ret)
 997                 return ret;
 998         drm->mode_config.funcs = &repaper_mode_config_funcs;
 999
1000         epd->spi = spi;
1001
1002         epd->panel_on = devm_gpiod_get(dev, "panel-on", GPIOD_OUT_LOW);
1003         if (IS_ERR(epd->panel_on)) {
1004                 ret = PTR_ERR(epd->panel_on);
1005                 if (ret != -EPROBE_DEFER)
1006                         DRM_DEV_ERROR(dev, "Failed to get gpio 'panel-on'\n");
1007                 return ret;
1008         }
1009
1010         epd->discharge = devm_gpiod_get(dev, "discharge", GPIOD_OUT_LOW);
1011         if (IS_ERR(epd->discharge)) {
1012                 ret = PTR_ERR(epd->discharge);
1013                 if (ret != -EPROBE_DEFER)
1014                         DRM_DEV_ERROR(dev, "Failed to get gpio 'discharge'\n");
1015                 return ret;
1016         }
1017
1018         epd->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
1019         if (IS_ERR(epd->reset)) {
1020                 ret = PTR_ERR(epd->reset);
1021                 if (ret != -EPROBE_DEFER)
1022                         DRM_DEV_ERROR(dev, "Failed to get gpio 'reset'\n");
1023                 return ret;
1024         }
1025
1026         epd->busy = devm_gpiod_get(dev, "busy", GPIOD_IN);
1027         if (IS_ERR(epd->busy)) {
1028                 ret = PTR_ERR(epd->busy);
1029                 if (ret != -EPROBE_DEFER)
1030                         DRM_DEV_ERROR(dev, "Failed to get gpio 'busy'\n");
1031                 return ret;
1032         }
1033
1034         if (!device_property_read_string(dev, "pervasive,thermal-zone",
1035                                          &thermal_zone)) {
1036                 epd->thermal = thermal_zone_get_zone_by_name(thermal_zone);
1037                 if (IS_ERR(epd->thermal)) {
1038                         DRM_DEV_ERROR(dev, "Failed to get thermal zone: %s\n", thermal_zone);
1039                         return PTR_ERR(epd->thermal);
1040                 }
1041         }
1042
1043         switch (model) {
1044         case E1144CS021:
1045                 mode = &repaper_e1144cs021_mode;
1046                 epd->channel_select = repaper_e1144cs021_cs;
1047                 epd->stage_time = 480;
1048                 epd->bytes_per_scan = 96 / 4;
1049                 epd->middle_scan = true; /* data-scan-data */
1050                 epd->pre_border_byte = false;
1051                 epd->border_byte = REPAPER_BORDER_BYTE_ZERO;
1052                 break;
1053
1054         case E1190CS021:
1055                 mode = &repaper_e1190cs021_mode;
1056                 epd->channel_select = repaper_e1190cs021_cs;
1057                 epd->stage_time = 480;
1058                 epd->bytes_per_scan = 128 / 4 / 2;
1059                 epd->middle_scan = false; /* scan-data-scan */
1060                 epd->pre_border_byte = false;
1061                 epd->border_byte = REPAPER_BORDER_BYTE_SET;
1062                 break;
1063
1064         case E2200CS021:
1065                 mode = &repaper_e2200cs021_mode;
1066                 epd->channel_select = repaper_e2200cs021_cs;
1067                 epd->stage_time = 480;
1068                 epd->bytes_per_scan = 96 / 4;
1069                 epd->middle_scan = true; /* data-scan-data */
1070                 epd->pre_border_byte = true;
1071                 epd->border_byte = REPAPER_BORDER_BYTE_NONE;
1072                 break;
1073
1074         case E2271CS021:
1075                 epd->border = devm_gpiod_get(dev, "border", GPIOD_OUT_LOW);
1076                 if (IS_ERR(epd->border)) {
1077                         ret = PTR_ERR(epd->border);
1078                         if (ret != -EPROBE_DEFER)
1079                                 DRM_DEV_ERROR(dev, "Failed to get gpio 'border'\n");
1080                         return ret;
1081                 }
1082
1083                 mode = &repaper_e2271cs021_mode;
1084                 epd->channel_select = repaper_e2271cs021_cs;
1085                 epd->stage_time = 630;
1086                 epd->bytes_per_scan = 176 / 4;
1087                 epd->middle_scan = true; /* data-scan-data */
1088                 epd->pre_border_byte = true;
1089                 epd->border_byte = REPAPER_BORDER_BYTE_NONE;
1090                 break;
1091
1092         default:
1093                 return -ENODEV;
1094         }
1095
1096         epd->mode = mode;
1097         epd->width = mode->hdisplay;
1098         epd->height = mode->vdisplay;
1099         epd->factored_stage_time = epd->stage_time;
1100
1101         line_buffer_size = 2 * epd->width / 8 + epd->bytes_per_scan + 2;
1102         epd->line_buffer = devm_kzalloc(dev, line_buffer_size, GFP_KERNEL);
1103         if (!epd->line_buffer)
1104                 return -ENOMEM;
1105
1106         epd->current_frame = devm_kzalloc(dev, epd->width * epd->height / 8,
1107                                           GFP_KERNEL);
1108         if (!epd->current_frame)
1109                 return -ENOMEM;
1110
1111         drm->mode_config.min_width = mode->hdisplay;
1112         drm->mode_config.max_width = mode->hdisplay;
1113         drm->mode_config.min_height = mode->vdisplay;
1114         drm->mode_config.max_height = mode->vdisplay;
1115
1116         drm_connector_helper_add(&epd->connector, &repaper_connector_hfuncs);
1117         ret = drm_connector_init(drm, &epd->connector, &repaper_connector_funcs,
1118                                  DRM_MODE_CONNECTOR_SPI);
1119         if (ret)
1120                 return ret;
1121
1122         ret = drm_simple_display_pipe_init(drm, &epd->pipe, &repaper_pipe_funcs,
1123                                            repaper_formats, ARRAY_SIZE(repaper_formats),
1124                                            NULL, &epd->connector);
1125         if (ret)
1126                 return ret;
1127
1128         drm_mode_config_reset(drm);
1129
1130         ret = drm_dev_register(drm, 0);
1131         if (ret)
1132                 return ret;
1133
1134         spi_set_drvdata(spi, drm);
1135
1136         DRM_DEBUG_DRIVER("SPI speed: %uMHz\n", spi->max_speed_hz / 1000000);
1137
1138         drm_fbdev_generic_setup(drm, 0);
1139
1140         return 0;
1141 }
1142
1143 static int repaper_remove(struct spi_device *spi)
1144 {
1145         struct drm_device *drm = spi_get_drvdata(spi);
1146
1147         drm_dev_unplug(drm);
1148         drm_atomic_helper_shutdown(drm);
1149
1150         return 0;
1151 }
1152
1153 static void repaper_shutdown(struct spi_device *spi)
1154 {
1155         drm_atomic_helper_shutdown(spi_get_drvdata(spi));
1156 }
1157
1158 static struct spi_driver repaper_spi_driver = {
1159         .driver = {
1160                 .name = "repaper",
1161                 .of_match_table = repaper_of_match,
1162         },
1163         .id_table = repaper_id,
1164         .probe = repaper_probe,
1165         .remove = repaper_remove,
1166         .shutdown = repaper_shutdown,
1167 };
1168 module_spi_driver(repaper_spi_driver);
1169
1170 MODULE_DESCRIPTION("Pervasive Displays RePaper DRM driver");
1171 MODULE_AUTHOR("Noralf Trønnes");
1172 MODULE_LICENSE("GPL");