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